From 3867f3fbdfb7607223f7bc32cc2dc03890400f42 Mon Sep 17 00:00:00 2001
From: Jeongkyu Shin <inureyes@gmail.com>
Date: Fri, 3 Apr 2026 14:21:53 +0900
Subject: [PATCH 1/2] update: Upgrade all dependencies to latest versions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Upgrade 30+ crate dependencies to latest compatible versions
- Sync bssh-russh fork with upstream russh 0.59.0 (from 0.56.0)
  - 21% throughput improvement from CryptoVec → bytes::Bytes migration
  - RSA Marvin attack mitigation, ml-kem replacement, aws-lc-rs security patch
  - Certificate-based SSH agent authentication support
  - Re-apply PTY output batch processing patch on new codebase
- Migrate OpenTelemetry from 0.21 to 0.31
  - Rewrite otel.rs for new SdkLoggerProvider, Resource::builder, LogRecord API
- Adapt bssh code to russh 0.59 API changes
  - Handle::data/extended_data now takes impl Into<bytes::Bytes>
  - AgentIdentity comparison via public_key()
  - Add bytes crate as direct dependency
- Keep rand at 0.8 in main crate (ssh-key requires rand_core 0.6)
---
 Cargo.lock                                    | 1265 ++++++++---------
 Cargo.toml                                    |   61 +-
 benches/large_output_benchmark.rs             |   12 +-
 crates/bssh-russh/Cargo.toml                  |   20 +-
 .../bssh-russh/patches/handle-data-fix.patch  |   11 +-
 crates/bssh-russh/src/auth.rs                 |   28 +-
 crates/bssh-russh/src/channels/io/tx.rs       |    8 +-
 crates/bssh-russh/src/channels/mod.rs         |    7 +-
 crates/bssh-russh/src/cipher/benchmark.rs     |    9 +-
 crates/bssh-russh/src/cipher/block.rs         |    8 +-
 crates/bssh-russh/src/cipher/gcm.rs           |   11 +-
 crates/bssh-russh/src/cipher/mod.rs           |   28 +-
 crates/bssh-russh/src/client/encrypted.rs     |  123 +-
 crates/bssh-russh/src/client/kex.rs           |   33 +-
 crates/bssh-russh/src/client/mod.rs           |  126 +-
 crates/bssh-russh/src/client/session.rs       |    8 +-
 crates/bssh-russh/src/client/test.rs          |   10 +-
 crates/bssh-russh/src/compression.rs          |   69 +-
 crates/bssh-russh/src/kex/curve25519.rs       |   20 +-
 crates/bssh-russh/src/kex/dh/groups.rs        |    4 +-
 crates/bssh-russh/src/kex/dh/mod.rs           |   18 +-
 crates/bssh-russh/src/kex/ecdh_nistp.rs       |   29 +-
 crates/bssh-russh/src/kex/hybrid_mlkem.rs     |  105 +-
 crates/bssh-russh/src/kex/mod.rs              |   14 +-
 crates/bssh-russh/src/kex/none.rs             |   13 +-
 crates/bssh-russh/src/keys/agent/client.rs    |  161 ++-
 crates/bssh-russh/src/keys/agent/mod.rs       |  178 +++
 crates/bssh-russh/src/keys/agent/server.rs    |   22 +-
 crates/bssh-russh/src/keys/format/pkcs8.rs    |    3 +-
 crates/bssh-russh/src/keys/key.rs             |    5 +-
 crates/bssh-russh/src/keys/known_hosts.rs     |    3 +-
 crates/bssh-russh/src/keys/mod.rs             |  604 +++++++-
 crates/bssh-russh/src/lib_inner.rs            |    9 +-
 crates/bssh-russh/src/negotiation.rs          |    7 +-
 crates/bssh-russh/src/parsing.rs              |    8 +-
 crates/bssh-russh/src/server/encrypted.rs     |   54 +-
 crates/bssh-russh/src/server/kex.rs           |   29 +-
 crates/bssh-russh/src/server/mod.rs           |   15 +-
 crates/bssh-russh/src/server/session.rs       |   30 +-
 crates/bssh-russh/src/session.rs              |  308 +++-
 crates/bssh-russh/src/ssh_read.rs             |  122 +-
 crates/bssh-russh/src/sshbuffer.rs            |   49 +-
 crates/bssh-russh/src/tests.rs                |  304 +++-
 src/executor/stream_manager.rs                |    8 +-
 src/jump/chain/auth.rs                        |    2 +-
 src/server/audit/otel.rs                      |  243 ++--
 src/server/exec.rs                            |   16 +-
 src/server/scp.rs                             |    4 +-
 src/server/shell.rs                           |    4 +-
 src/ssh/tokio_client/authentication.rs        |   10 +-
 src/ssh/tokio_client/channel_manager.rs       |   10 +-
 tests/streaming_integration_tests.rs          |   50 +-
 52 files changed, 2964 insertions(+), 1334 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e81f22b9..4ce0dcb4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -97,9 +97,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "anstream"
-version = "0.6.21"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -118,9 +118,9 @@ checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.7"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
 dependencies = [
  "utf8parse",
 ]
@@ -147,9 +147,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.100"
+version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
 [[package]]
 name = "argon2"
@@ -199,7 +199,7 @@ checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -236,9 +236,9 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "aws-lc-rs"
-version = "1.15.2"
+version = "1.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a88aab2464f1f25453baa7a07c84c5b7684e274054ba06817f382357f77a288"
+checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc"
 dependencies = [
  "aws-lc-sys",
  "untrusted 0.7.1",
@@ -247,9 +247,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.35.0"
+version = "0.39.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b45afffdee1e7c9126814751f88dddc747f41d91da16c9551a0f1e8a11e788a1"
+checksum = "83a25cf98105baa966497416dbd42565ce3a8cf8dbfd59803ec9ad46f3126399"
 dependencies = [
  "cc",
  "cmake",
@@ -257,51 +257,6 @@ dependencies = [
  "fs_extra",
 ]
 
-[[package]]
-name = "axum"
-version = "0.6.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b829e4e32b91e643de6eafe82b1d90675f5874230191a4ffbc1b336dec4d6bf"
-dependencies = [
- "async-trait",
- "axum-core",
- "bitflags 1.3.2",
- "bytes",
- "futures-util",
- "http 0.2.12",
- "http-body 0.4.6",
- "hyper 0.14.32",
- "itoa",
- "matchit",
- "memchr",
- "mime",
- "percent-encoding",
- "pin-project-lite",
- "rustversion",
- "serde",
- "sync_wrapper",
- "tower",
- "tower-layer",
- "tower-service",
-]
-
-[[package]]
-name = "axum-core"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "759fa577a247914fd3f7f76d62972792636412fbfd634cd452f6a385a74d2d2c"
-dependencies = [
- "async-trait",
- "bytes",
- "futures-util",
- "http 0.2.12",
- "http-body 0.4.6",
- "mime",
- "rustversion",
- "tower-layer",
- "tower-service",
-]
-
 [[package]]
 name = "base16ct"
 version = "0.2.0"
@@ -314,12 +269,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fd307490d624467aa6f74b0eabb77633d1f758a7b25f12bceb0b22e08d9726f6"
 
-[[package]]
-name = "base64"
-version = "0.21.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
-
 [[package]]
 name = "base64"
 version = "0.22.1"
@@ -334,13 +283,13 @@ checksum = "7d809780667f4410e7c41b07f52439b94d2bdf8528eeedc287fa38d3b7f95d82"
 
 [[package]]
 name = "bcrypt"
-version = "0.16.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b1866ecef4f2d06a0bb77880015fdf2b89e25a1c2e5addacb87e459c86dc67e"
+checksum = "523ab528ce3a7ada6597f8ccf5bd8d85ebe26d5edf311cad4d1d3cfb2d357ac6"
 dependencies = [
- "base64 0.22.1",
+ "base64",
  "blowfish",
- "getrandom 0.2.16",
+ "getrandom 0.4.2",
  "subtle",
  "zeroize",
 ]
@@ -379,9 +328,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.10.0"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
 dependencies = [
  "serde_core",
 ]
@@ -410,7 +359,7 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "96eb4cdd6cf1b31d671e9efe75c5d1ec614776856cefbe109ca373554a6d514f"
 dependencies = [
- "hybrid-array",
+ "hybrid-array 0.4.5",
 ]
 
 [[package]]
@@ -453,6 +402,7 @@ dependencies = [
  "atty",
  "bcrypt",
  "bssh-russh",
+ "bytes",
  "chrono",
  "clap",
  "criterion",
@@ -471,7 +421,7 @@ dependencies = [
  "lru",
  "mockall",
  "mockito",
- "nix 0.30.1",
+ "nix 0.31.2",
  "once_cell",
  "opentelemetry",
  "opentelemetry-otlp",
@@ -491,12 +441,12 @@ dependencies = [
  "serde_yaml",
  "serial_test",
  "shell-words",
- "signal-hook 0.4.1",
+ "signal-hook 0.4.3",
  "smallvec",
  "ssh-key",
  "tempfile",
  "terminal_size",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "tokio",
  "tokio-rustls",
  "tokio-test",
@@ -512,12 +462,12 @@ dependencies = [
 
 [[package]]
 name = "bssh-russh"
-version = "0.56.0"
+version = "0.59.0"
 dependencies = [
  "aes",
  "async-trait",
  "aws-lc-rs",
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "block-padding",
  "byteorder",
  "bytes",
@@ -539,12 +489,11 @@ dependencies = [
  "getrandom 0.2.16",
  "hex-literal",
  "hmac",
- "home",
  "inout",
  "internal-russh-forked-ssh-key",
- "libcrux-ml-kem",
  "log",
  "md5",
+ "ml-kem",
  "num-bigint",
  "p256",
  "p384",
@@ -553,8 +502,8 @@ dependencies = [
  "pkcs1 0.8.0-rc.4",
  "pkcs5",
  "pkcs8 0.10.2",
- "rand 0.8.5",
- "rand_core 0.6.4",
+ "rand 0.9.2",
+ "rand_core 0.10.0-rc-3",
  "ring",
  "rsa 0.10.0-rc.11",
  "russh-cryptovec",
@@ -566,7 +515,7 @@ dependencies = [
  "spki 0.7.3",
  "ssh-encoding",
  "subtle",
- "thiserror 1.0.69",
+ "thiserror 2.0.18",
  "tokio",
  "typenum",
  "yasna",
@@ -658,9 +607,9 @@ dependencies = [
 
 [[package]]
 name = "chrono"
-version = "0.4.42"
+version = "0.4.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
 dependencies = [
  "iana-time-zone",
  "js-sys",
@@ -709,9 +658,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.54"
+version = "4.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6e6ff9dcd79cff5cd969a17a545d79e84ab086e444102a591e288a8aa3ce394"
+checksum = "b193af5b67834b676abd72466a96c1024e6a6ad978a1f484bd90b85c94041351"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -719,9 +668,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.54"
+version = "4.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa42cf4d2b7a41bc8f663a7cab4031ebafa1bf3875705bfaf8466dc60ab52c00"
+checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
 dependencies = [
  "anstream",
  "anstyle",
@@ -731,21 +680,21 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.49"
+version = "4.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671"
+checksum = "1110bd8a634a1ab8cb04345d8d878267d57c3cf1b38d91b71af6686408bbca6a"
 dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.7.6"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
+checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
 
 [[package]]
 name = "clipboard-win"
@@ -817,18 +766,6 @@ version = "0.4.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d"
 
-[[package]]
-name = "console"
-version = "0.15.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
-dependencies = [
- "encode_unicode",
- "libc",
- "once_cell",
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "console"
 version = "0.16.2"
@@ -899,17 +836,6 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
-[[package]]
-name = "core-models"
-version = "0.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0940496e5c83c54f3b753d5317daec82e8edac71c33aaa1f666d76f518de2444"
-dependencies = [
- "hax-lib",
- "pastey",
- "rand 0.9.2",
-]
-
 [[package]]
 name = "cpufeatures"
 version = "0.2.17"
@@ -963,15 +889,6 @@ dependencies = [
  "itertools 0.13.0",
 ]
 
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
-dependencies = [
- "crossbeam-utils",
-]
-
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.6"
@@ -1003,7 +920,7 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "crossterm_winapi",
  "derive_more",
  "document-features",
@@ -1071,7 +988,7 @@ version = "0.2.0-rc.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41b8986f836d4aeb30ccf4c9d3bd562fd716074cfd7fc4a2948359fbd21ed809"
 dependencies = [
- "hybrid-array",
+ "hybrid-array 0.4.5",
 ]
 
 [[package]]
@@ -1106,12 +1023,12 @@ dependencies = [
 
 [[package]]
 name = "ctrlc"
-version = "3.5.1"
+version = "3.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73736a89c4aff73035ba2ed2e565061954da00d4970fc9ac25dcc85a2a20d790"
+checksum = "e0b1fab2ae45819af2d0731d60f2afe17227ebb1a1538a236da84c93e9a60162"
 dependencies = [
  "dispatch2",
- "nix 0.30.1",
+ "nix 0.31.2",
  "windows-sys 0.61.2",
 ]
 
@@ -1148,7 +1065,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -1171,7 +1088,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -1182,7 +1099,7 @@ checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -1199,7 +1116,7 @@ checksum = "780eb241654bf097afb00fc5f054a09b687dad862e485fdcf8399bb056565370"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -1258,7 +1175,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustc_version",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -1329,7 +1246,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "89a09f22a6c6069a18470eb92d2298acf25463f14256d24778e1230d789a2aec"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "block2",
  "libc",
  "objc2",
@@ -1343,7 +1260,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -1457,9 +1374,9 @@ checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
 
 [[package]]
 name = "endian-type"
-version = "0.1.2"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
+checksum = "869b0adbda23651a9c5c0c3d270aac9fcb52e8622a8f2b17e57802d7791962f2"
 
 [[package]]
 name = "enum_dispatch"
@@ -1470,7 +1387,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -1520,17 +1437,6 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
-[[package]]
-name = "fd-lock"
-version = "4.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce92ff622d6dadf7349484f42c93271a0d49b7cc4d466a936405bacbe10aa78"
-dependencies = [
- "cfg-if",
- "rustix",
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "ff"
 version = "0.13.1"
@@ -1604,6 +1510,12 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
 [[package]]
 name = "foldhash"
 version = "0.2.0"
@@ -1633,9 +1545,9 @@ checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
 
 [[package]]
 name = "futures"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1648,9 +1560,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -1658,15 +1570,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -1675,38 +1587,38 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
 
 [[package]]
 name = "futures-macro"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "futures-sink"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
 
 [[package]]
 name = "futures-task"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
 
 [[package]]
 name = "futures-util"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1716,7 +1628,6 @@ dependencies = [
  "futures-task",
  "memchr",
  "pin-project-lite",
- "pin-utils",
  "slab",
 ]
 
@@ -1763,8 +1674,21 @@ checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
  "cfg-if",
  "libc",
- "r-efi",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
  "wasip2",
+ "wasip3",
 ]
 
 [[package]]
@@ -1794,25 +1718,6 @@ dependencies = [
  "subtle",
 ]
 
-[[package]]
-name = "h2"
-version = "0.3.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d"
-dependencies = [
- "bytes",
- "fnv",
- "futures-core",
- "futures-sink",
- "futures-util",
- "http 0.2.12",
- "indexmap 2.13.0",
- "slab",
- "tokio",
- "tokio-util",
- "tracing",
-]
-
 [[package]]
 name = "h2"
 version = "0.4.13"
@@ -1824,8 +1729,8 @@ dependencies = [
  "fnv",
  "futures-core",
  "futures-sink",
- "http 1.4.0",
- "indexmap 2.13.0",
+ "http",
+ "indexmap",
  "slab",
  "tokio",
  "tokio-util",
@@ -1845,9 +1750,12 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.12.3"
+version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash 0.1.5",
+]
 
 [[package]]
 name = "hashbrown"
@@ -1857,44 +1765,7 @@ checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 dependencies = [
  "allocator-api2",
  "equivalent",
- "foldhash",
-]
-
-[[package]]
-name = "hax-lib"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74d9ba66d1739c68e0219b2b2238b5c4145f491ebf181b9c6ab561a19352ae86"
-dependencies = [
- "hax-lib-macros",
- "num-bigint",
- "num-traits",
-]
-
-[[package]]
-name = "hax-lib-macros"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24ba777a231a58d1bce1d68313fa6b6afcc7966adef23d60f45b8a2b9b688bf1"
-dependencies = [
- "hax-lib-macros-types",
- "proc-macro-error2",
- "proc-macro2",
- "quote",
- "syn 2.0.114",
-]
-
-[[package]]
-name = "hax-lib-macros-types"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "867e19177d7425140b417cd27c2e05320e727ee682e98368f88b7194e80ad515"
-dependencies = [
- "proc-macro2",
- "quote",
- "serde",
- "serde_json",
- "uuid",
+ "foldhash 0.2.0",
 ]
 
 [[package]]
@@ -1926,9 +1797,9 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "hex-literal"
-version = "0.4.1"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46"
+checksum = "e712f64ec3850b98572bffac52e2c6f282b29fe6c5fa6d42334b30be438d95c1"
 
 [[package]]
 name = "hkdf"
@@ -1957,17 +1828,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "http"
-version = "0.2.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
-dependencies = [
- "bytes",
- "fnv",
- "itoa",
-]
-
 [[package]]
 name = "http"
 version = "1.4.0"
@@ -1978,17 +1838,6 @@ dependencies = [
  "itoa",
 ]
 
-[[package]]
-name = "http-body"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
-dependencies = [
- "bytes",
- "http 0.2.12",
- "pin-project-lite",
-]
-
 [[package]]
 name = "http-body"
 version = "1.0.1"
@@ -1996,7 +1845,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
  "bytes",
- "http 1.4.0",
+ "http",
 ]
 
 [[package]]
@@ -2007,8 +1856,8 @@ checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
 dependencies = [
  "bytes",
  "futures-core",
- "http 1.4.0",
- "http-body 1.0.1",
+ "http",
+ "http-body",
  "pin-project-lite",
 ]
 
@@ -2026,35 +1875,20 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "hybrid-array"
-version = "0.4.5"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f471e0a81b2f90ffc0cb2f951ae04da57de8baa46fa99112b062a5173a5088d0"
+checksum = "f2d35805454dc9f8662a98d6d61886ffe26bd465f5960e0e55345c70d5c0d2a9"
 dependencies = [
  "typenum",
 ]
 
 [[package]]
-name = "hyper"
-version = "0.14.32"
+name = "hybrid-array"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"
+checksum = "f471e0a81b2f90ffc0cb2f951ae04da57de8baa46fa99112b062a5173a5088d0"
 dependencies = [
- "bytes",
- "futures-channel",
- "futures-core",
- "futures-util",
- "h2 0.3.27",
- "http 0.2.12",
- "http-body 0.4.6",
- "httparse",
- "httpdate",
- "itoa",
- "pin-project-lite",
- "socket2 0.5.10",
- "tokio",
- "tower-service",
- "tracing",
- "want",
+ "typenum",
 ]
 
 [[package]]
@@ -2067,9 +1901,9 @@ dependencies = [
  "bytes",
  "futures-channel",
  "futures-core",
- "h2 0.4.13",
- "http 1.4.0",
- "http-body 1.0.1",
+ "h2",
+ "http",
+ "http-body",
  "httparse",
  "httpdate",
  "itoa",
@@ -2077,18 +1911,20 @@ dependencies = [
  "pin-utils",
  "smallvec",
  "tokio",
+ "want",
 ]
 
 [[package]]
 name = "hyper-timeout"
-version = "0.4.1"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbb958482e8c7be4bc3cf272a766a2b0bf1a6755e7a6ae777f017a31d11b13b1"
+checksum = "2b90d566bffbce6a75bd8b09a05aa8c2cb1fabb6cb348f8840c9e4c90a0d83b0"
 dependencies = [
- "hyper 0.14.32",
+ "hyper",
+ "hyper-util",
  "pin-project-lite",
  "tokio",
- "tokio-io-timeout",
+ "tower-service",
 ]
 
 [[package]]
@@ -2097,13 +1933,22 @@ version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "727805d60e7938b76b826a6ef209eb70eaa1812794f9424d4a4e2d740662df5f"
 dependencies = [
+ "base64",
  "bytes",
+ "futures-channel",
  "futures-core",
- "http 1.4.0",
- "http-body 1.0.1",
- "hyper 1.8.1",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "ipnet",
+ "libc",
+ "percent-encoding",
  "pin-project-lite",
+ "socket2",
  "tokio",
+ "tower-service",
+ "tracing",
 ]
 
 [[package]]
@@ -2211,6 +2056,12 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -2238,16 +2089,6 @@ dependencies = [
  "icu_properties",
 ]
 
-[[package]]
-name = "indexmap"
-version = "1.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
-dependencies = [
- "autocfg",
- "hashbrown 0.12.3",
-]
-
 [[package]]
 name = "indexmap"
 version = "2.13.0"
@@ -2256,15 +2097,17 @@ checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
 dependencies = [
  "equivalent",
  "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "indicatif"
-version = "0.18.3"
+version = "0.18.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9375e112e4b463ec1b1c6c011953545c65a30164fbab5b581df32b3abf0dcb88"
+checksum = "25470f23803092da7d239834776d653104d551bc4d7eacaf31e6837854b8e9eb"
 dependencies = [
- "console 0.16.2",
+ "console",
  "portable-atomic",
  "unicode-width",
  "unit-prefix",
@@ -2292,11 +2135,11 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.46.0"
+version = "1.47.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b66886d14d18d420ab5052cbff544fc5d34d0b2cdd35eb5976aaa10a4a472e5"
+checksum = "7b4a6248eb93a4401ed2f37dfe8ea592d3cf05b7cf4f8efa867b6895af7e094e"
 dependencies = [
- "console 0.15.11",
+ "console",
  "once_cell",
  "similar",
  "tempfile",
@@ -2312,7 +2155,7 @@ dependencies = [
  "indoc",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2336,6 +2179,7 @@ dependencies = [
  "rand_core 0.6.4",
  "rsa 0.10.0-rc.11",
  "sec1",
+ "serde",
  "sha1 0.10.6",
  "sha1 0.11.0-rc.3",
  "sha2 0.10.9",
@@ -2347,12 +2191,25 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "ipnet"
+version = "2.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
+
 [[package]]
 name = "ipnetwork"
-version = "0.20.0"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf466541e9d546596ee94f9f69590f89473455f88372423e0008fc1a7daf100e"
+checksum = "cf370abdafd54d13e54a620e8c3e1145f28e46cc9d704bc6d94414559df41763"
+
+[[package]]
+name = "iri-string"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25e659a4bb38e810ebc252e53b5814ff908a8c58c2a9ce2fae1bbec24cbf4e20"
 dependencies = [
+ "memchr",
  "serde",
 ]
 
@@ -2362,15 +2219,6 @@ version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
-[[package]]
-name = "itertools"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itertools"
 version = "0.13.0"
@@ -2407,10 +2255,12 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.83"
+version = "0.3.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
+checksum = "2e04e2ef80ce82e13552136fabeef8a5ed1f985a96805761cbb9a2c34e7664d9"
 dependencies = [
+ "cfg-if",
+ "futures-util",
  "once_cell",
  "wasm-bindgen",
 ]
@@ -2423,95 +2273,54 @@ checksum = "8fe90c1150662e858c7d5f945089b7517b0a80d8bf7ba4b1b5ffc984e7230a5b"
 dependencies = [
  "hashbrown 0.16.1",
  "portable-atomic",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "lab"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf36173d4167ed999940f804952e6b08197cae5ad5d572eb4db150ce8ad5d58f"
-
-[[package]]
-name = "lazy_static"
-version = "1.5.0"
+name = "keccak"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+checksum = "cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653"
 dependencies = [
- "spin",
+ "cpufeatures",
 ]
 
 [[package]]
-name = "libc"
-version = "0.2.180"
+name = "kem"
+version = "0.3.0-pre.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
-
-[[package]]
-name = "libcrux-intrinsics"
-version = "0.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc9ee7ef66569dd7516454fe26de4e401c0c62073929803486b96744594b9632"
+checksum = "2b8645470337db67b01a7f966decf7d0bafedbae74147d33e641c67a91df239f"
 dependencies = [
- "core-models",
- "hax-lib",
+ "rand_core 0.6.4",
+ "zeroize",
 ]
 
 [[package]]
-name = "libcrux-ml-kem"
-version = "0.0.4"
+name = "lab"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bb6a88086bf11bd2ec90926c749c4a427f2e59841437dbdede8cde8a96334ab"
-dependencies = [
- "hax-lib",
- "libcrux-intrinsics",
- "libcrux-platform",
- "libcrux-secrets",
- "libcrux-sha3",
- "libcrux-traits",
- "rand 0.9.2",
- "tls_codec",
-]
+checksum = "bf36173d4167ed999940f804952e6b08197cae5ad5d572eb4db150ce8ad5d58f"
 
 [[package]]
-name = "libcrux-platform"
-version = "0.0.2"
+name = "lazy_static"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db82d058aa76ea315a3b2092f69dfbd67ddb0e462038a206e1dcd73f058c0778"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 dependencies = [
- "libc",
+ "spin",
 ]
 
 [[package]]
-name = "libcrux-secrets"
-version = "0.0.4"
+name = "leb128fmt"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e4dbbf6bc9f2bc0f20dc3bea3e5c99adff3bdccf6d2a40488963da69e2ec307"
-dependencies = [
- "hax-lib",
-]
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
 
 [[package]]
-name = "libcrux-sha3"
-version = "0.0.4"
+name = "libc"
+version = "0.2.184"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2400bec764d1c75b8a496d5747cffe32f1fb864a12577f0aca2f55a92021c962"
-dependencies = [
- "hax-lib",
- "libcrux-intrinsics",
- "libcrux-platform",
- "libcrux-traits",
-]
-
-[[package]]
-name = "libcrux-traits"
-version = "0.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9adfd58e79d860f6b9e40e35127bfae9e5bd3ade33201d1347459011a2add034"
-dependencies = [
- "libcrux-secrets",
- "rand 0.9.2",
-]
+checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af"
 
 [[package]]
 name = "libm"
@@ -2525,7 +2334,7 @@ version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "libc",
 ]
 
@@ -2535,14 +2344,14 @@ version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f4de44e98ddbf09375cbf4d17714d18f39195f4f4894e8524501726fd9a8a4a"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
 ]
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.11.0"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
 [[package]]
 name = "litemap"
@@ -2599,12 +2408,6 @@ dependencies = [
  "regex-automata",
 ]
 
-[[package]]
-name = "matchit"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
-
 [[package]]
 name = "md5"
 version = "0.7.0"
@@ -2613,9 +2416,9 @@ checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
 
 [[package]]
 name = "memchr"
-version = "2.7.6"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "memmem"
@@ -2632,12 +2435,6 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "mime"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
-
 [[package]]
 name = "minimal-lexical"
 version = "0.2.1"
@@ -2666,6 +2463,18 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "ml-kem"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de49b3df74c35498c0232031bb7e85f9389f913e2796169c8ab47a53993a18f"
+dependencies = [
+ "hybrid-array 0.2.3",
+ "kem",
+ "rand_core 0.6.4",
+ "sha3",
+]
+
 [[package]]
 name = "mockall"
 version = "0.14.0"
@@ -2689,23 +2498,23 @@ dependencies = [
  "cfg-if",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "mockito"
-version = "1.7.1"
+version = "1.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e0603425789b4a70fcc4ac4f5a46a566c116ee3e2a6b768dc623f7719c611de"
+checksum = "90820618712cab19cfc46b274c6c22546a82affcb3c3bdf0f29e3db8e1bb92c0"
 dependencies = [
  "assert-json-diff",
  "bytes",
  "colored",
  "futures-core",
- "http 1.4.0",
- "http-body 1.0.1",
+ "http",
+ "http-body",
  "http-body-util",
- "hyper 1.8.1",
+ "hyper",
  "hyper-util",
  "log",
  "pin-project-lite",
@@ -2732,7 +2541,7 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -2741,11 +2550,11 @@ dependencies = [
 
 [[package]]
 name = "nix"
-version = "0.30.1"
+version = "0.31.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
+checksum = "5d6d0705320c1e6ba1d912b5e37cf18071b6c2e9b7fa8215a1e8a7651966f5d3"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -2812,7 +2621,7 @@ checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2873,17 +2682,35 @@ dependencies = [
  "objc2-encode",
 ]
 
+[[package]]
+name = "objc2-core-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
+dependencies = [
+ "bitflags 2.11.0",
+]
+
 [[package]]
 name = "objc2-encode"
 version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
 
+[[package]]
+name = "objc2-system-configuration"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7216bd11cbda54ccabcab84d523dc93b858ec75ecfb3a7d89513fa22464da396"
+dependencies = [
+ "objc2-core-foundation",
+]
+
 [[package]]
 name = "once_cell"
-version = "1.21.3"
+version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "once_cell_polyfill"
@@ -2911,78 +2738,76 @@ checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
 
 [[package]]
 name = "opentelemetry"
-version = "0.21.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e32339a5dc40459130b3bd269e9892439f55b33e772d2a9d402a789baaf4e8a"
+checksum = "b84bcd6ae87133e903af7ef497404dda70c60d0ea14895fc8a5e6722754fc2a0"
 dependencies = [
  "futures-core",
  "futures-sink",
- "indexmap 2.13.0",
  "js-sys",
- "once_cell",
  "pin-project-lite",
- "thiserror 1.0.69",
- "urlencoding",
+ "thiserror 2.0.18",
+ "tracing",
+]
+
+[[package]]
+name = "opentelemetry-http"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7a6d09a73194e6b66df7c8f1b680f156d916a1a942abf2de06823dd02b7855d"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "http",
+ "opentelemetry",
+ "reqwest",
 ]
 
 [[package]]
 name = "opentelemetry-otlp"
-version = "0.14.0"
+version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f24cda83b20ed2433c68241f918d0f6fdec8b1d43b7a9590ab4420c5095ca930"
+checksum = "1f69cd6acbb9af919df949cd1ec9e5e7fdc2ef15d234b6b795aaa525cc02f71f"
 dependencies = [
- "async-trait",
- "futures-core",
- "http 0.2.12",
+ "http",
  "opentelemetry",
+ "opentelemetry-http",
  "opentelemetry-proto",
- "opentelemetry-semantic-conventions",
  "opentelemetry_sdk",
  "prost",
- "thiserror 1.0.69",
+ "reqwest",
+ "thiserror 2.0.18",
  "tokio",
  "tonic",
+ "tracing",
 ]
 
 [[package]]
 name = "opentelemetry-proto"
-version = "0.4.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2e155ce5cc812ea3d1dffbd1539aed653de4bf4882d60e6e04dcf0901d674e1"
+checksum = "a7175df06de5eaee9909d4805a3d07e28bb752c34cab57fa9cff549da596b30f"
 dependencies = [
  "opentelemetry",
  "opentelemetry_sdk",
  "prost",
  "tonic",
-]
-
-[[package]]
-name = "opentelemetry-semantic-conventions"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5774f1ef1f982ef2a447f6ee04ec383981a3ab99c8e77a1a7b30182e65bbc84"
-dependencies = [
- "opentelemetry",
+ "tonic-prost",
 ]
 
 [[package]]
 name = "opentelemetry_sdk"
-version = "0.21.2"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f16aec8a98a457a52664d69e0091bac3a0abd18ead9b641cb00202ba4e0efe4"
+checksum = "e14ae4f5991976fd48df6d843de219ca6d31b01daaab2dad5af2badeded372bd"
 dependencies = [
- "async-trait",
- "crossbeam-channel",
  "futures-channel",
  "futures-executor",
  "futures-util",
- "once_cell",
  "opentelemetry",
- "ordered-float",
  "percent-encoding",
- "rand 0.8.5",
- "serde_json",
- "thiserror 1.0.69",
+ "rand 0.9.2",
+ "thiserror 2.0.18",
  "tokio",
  "tokio-stream",
 ]
@@ -3004,9 +2829,9 @@ dependencies = [
 
 [[package]]
 name = "owo-colors"
-version = "4.2.3"
+version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c6901729fa79e91a0913333229e9ca5dc725089d1c363b2f4b4760709dc4a52"
+checksum = "d211803b9b6b570f68772237e415a029d5a50c65d382910b879fb19d3271f94d"
 
 [[package]]
 name = "p256"
@@ -3090,12 +2915,6 @@ dependencies = [
  "subtle",
 ]
 
-[[package]]
-name = "pastey"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec"
-
 [[package]]
 name = "pbkdf2"
 version = "0.12.2"
@@ -3160,7 +2979,7 @@ dependencies = [
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -3213,7 +3032,7 @@ dependencies = [
  "phf_shared",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -3242,7 +3061,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -3423,50 +3242,38 @@ dependencies = [
 ]
 
 [[package]]
-name = "primeorder"
-version = "0.13.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6"
-dependencies = [
- "elliptic-curve",
-]
-
-[[package]]
-name = "proc-macro-error-attr2"
-version = "2.0.0"
+name = "prettyplease"
+version = "0.2.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
  "proc-macro2",
- "quote",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "proc-macro-error2"
-version = "2.0.1"
+name = "primeorder"
+version = "0.13.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
+checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6"
 dependencies = [
- "proc-macro-error-attr2",
- "proc-macro2",
- "quote",
- "syn 2.0.114",
+ "elliptic-curve",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.105"
+version = "1.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "prost"
-version = "0.11.9"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b82eaa1d779e9a4bc1c3217db8ffbeabaae1dca241bf70183242128d48681cd"
+checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568"
 dependencies = [
  "bytes",
  "prost-derive",
@@ -3474,22 +3281,22 @@ dependencies = [
 
 [[package]]
 name = "prost-derive"
-version = "0.11.9"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5d2d8d10f3c6ded6da8b05b5fb3b8a5082514344d56c9f871412d29b4e075b4"
+checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b"
 dependencies = [
  "anyhow",
- "itertools 0.10.5",
+ "itertools 0.14.0",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.43"
+version = "1.0.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
 dependencies = [
  "proc-macro2",
 ]
@@ -3500,11 +3307,17 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
 [[package]]
 name = "radix_trie"
-version = "0.2.1"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c069c179fcdc6a2fe24d8d18305cf085fdbd4f922c041943e203685d6a1c58fd"
+checksum = "3b4431027dcd37fc2a73ef740b5f233aa805897935b8bce0195e41bbf9a3289a"
 dependencies = [
  "endian-type",
  "nibble_vec",
@@ -3595,7 +3408,7 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ef8dea09a92caaf73bff7adb70b76162e5937524058a7e5bff37869cbbec293"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "compact_str",
  "hashbrown 0.16.1",
  "indoc",
@@ -3603,7 +3416,7 @@ dependencies = [
  "kasuari",
  "lru",
  "strum",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "unicode-segmentation",
  "unicode-truncate",
  "unicode-width",
@@ -3647,7 +3460,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7dbfa023cd4e604c2553483820c5fe8aa9d71a42eea5aa77c6e7f35756612db"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "hashbrown 0.16.1",
  "indoc",
  "instability",
@@ -3686,7 +3499,7 @@ version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
 ]
 
 [[package]]
@@ -3697,14 +3510,14 @@ checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
 dependencies = [
  "getrandom 0.2.16",
  "libredox",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
 name = "regex"
-version = "1.12.2"
+version = "1.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -3729,6 +3542,40 @@ version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
+[[package]]
+name = "reqwest"
+version = "0.12.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "rfc6979"
 version = "0.4.0"
@@ -3816,15 +3663,14 @@ dependencies = [
 
 [[package]]
 name = "russh-cryptovec"
-version = "0.52.0"
+version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fb0ed583ff0f6b4aa44c7867dd7108df01b30571ee9423e250b4cc939f8c6cf"
+checksum = "36140e8a20297bc2e8338807c3d9ca911f7fa49d7539cbcd6d48d3befd70efd8"
 dependencies = [
- "libc",
  "log",
- "nix 0.29.0",
+ "nix 0.31.2",
  "ssh-encoding",
- "winapi",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3833,13 +3679,13 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3bb94393cafad0530145b8f626d8687f1ee1dedb93d7ba7740d6ae81868b13b5"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "bytes",
  "chrono",
  "flurry",
  "log",
  "serde",
- "thiserror 2.0.17",
+ "thiserror 2.0.18",
  "tokio",
  "tokio-util",
 ]
@@ -3867,11 +3713,11 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -3934,24 +3780,23 @@ checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
 [[package]]
 name = "rustyline"
-version = "17.0.2"
+version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e902948a25149d50edc1a8e0141aad50f54e22ba83ff988cf8f7c9ef07f50564"
+checksum = "4a990b25f351b25139ddc7f21ee3f6f56f86d6846b74ac8fad3a719a287cd4a0"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "cfg-if",
  "clipboard-win",
- "fd-lock",
  "home",
  "libc",
  "log",
  "memchr",
- "nix 0.30.1",
+ "nix 0.31.2",
  "radix_trie",
  "unicode-segmentation",
  "unicode-width",
  "utf8parse",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4045,11 +3890,11 @@ dependencies = [
 
 [[package]]
 name = "security-framework"
-version = "3.5.1"
+version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "core-foundation",
  "core-foundation-sys",
  "libc",
@@ -4058,9 +3903,9 @@ dependencies = [
 
 [[package]]
 name = "security-framework-sys"
-version = "2.15.0"
+version = "2.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -4105,7 +3950,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -4139,7 +3984,7 @@ version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
- "indexmap 2.13.0",
+ "indexmap",
  "itoa",
  "ryu",
  "serde",
@@ -4158,9 +4003,9 @@ dependencies = [
 
 [[package]]
 name = "serial_test"
-version = "3.3.1"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d0b343e184fc3b7bb44dff0705fffcf4b3756ba6aff420dddd8b24ca145e555"
+checksum = "911bd979bf1070a3f3aa7b691a3b3e9968f339ceeec89e08c280a8a22207a32f"
 dependencies = [
  "futures-executor",
  "futures-util",
@@ -4173,13 +4018,13 @@ dependencies = [
 
 [[package]]
 name = "serial_test_derive"
-version = "3.3.1"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f50427f258fb77356e4cd4aa0e87e2bd2c66dbcee41dc405282cae2bfc26c83"
+checksum = "0a7d91949b85b0d2fb687445e448b40d322b6b3e4af6b44a29b21d9a5f33e6d9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -4226,6 +4071,16 @@ dependencies = [
  "digest 0.11.0-rc.5",
 ]
 
+[[package]]
+name = "sha3"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
+dependencies = [
+ "digest 0.10.7",
+ "keccak",
+]
+
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -4259,9 +4114,9 @@ dependencies = [
 
 [[package]]
 name = "signal-hook"
-version = "0.4.1"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a37d01603c37b5466f808de79f845c7116049b0579adb70a6b7d47c1fa3a952"
+checksum = "3b57709da74f9ff9f4a27dce9526eec25ca8407c45a7887243b031a58935fb8e"
 dependencies = [
  "libc",
  "signal-hook-registry",
@@ -4338,16 +4193,6 @@ version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
-[[package]]
-name = "socket2"
-version = "0.5.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
-dependencies = [
- "libc",
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "socket2"
 version = "0.6.1"
@@ -4469,7 +4314,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -4491,9 +4336,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.114"
+version = "2.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4502,9 +4347,12 @@ dependencies = [
 
 [[package]]
 name = "sync_wrapper"
-version = "0.1.2"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+dependencies = [
+ "futures-core",
+]
 
 [[package]]
 name = "synstructure"
@@ -4514,17 +4362,17 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "tempfile"
-version = "3.24.0"
+version = "3.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand",
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "once_cell",
  "rustix",
  "windows-sys 0.61.2",
@@ -4532,12 +4380,12 @@ dependencies = [
 
 [[package]]
 name = "terminal_size"
-version = "0.4.3"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60b8cb979cb11c32ce1603f8137b22262a9d131aaa5c37b5678025f22b8becd0"
+checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874"
 dependencies = [
  "rustix",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4574,8 +4422,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4676b37242ccbd1aabf56edb093a4827dc49086c0ffd764a5705899e0f35f8f7"
 dependencies = [
  "anyhow",
- "base64 0.22.1",
- "bitflags 2.10.0",
+ "base64",
+ "bitflags 2.11.0",
  "fancy-regex",
  "filedescriptor",
  "finl_unicode",
@@ -4620,11 +4468,11 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.17"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
 dependencies = [
- "thiserror-impl 2.0.17",
+ "thiserror-impl 2.0.18",
 ]
 
 [[package]]
@@ -4635,18 +4483,18 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.17"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -4708,32 +4556,11 @@ dependencies = [
  "serde_json",
 ]
 
-[[package]]
-name = "tls_codec"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0de2e01245e2bb89d6f05801c564fa27624dbd7b1846859876c7dad82e90bf6b"
-dependencies = [
- "tls_codec_derive",
- "zeroize",
-]
-
-[[package]]
-name = "tls_codec_derive"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d2e76690929402faae40aebdda620a2c0e25dd6d3b9afe48867dfd95991f4bd"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.114",
-]
-
 [[package]]
 name = "tokio"
-version = "1.49.0"
+version = "1.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
 dependencies = [
  "bytes",
  "libc",
@@ -4741,21 +4568,11 @@ dependencies = [
  "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.6.1",
+ "socket2",
  "tokio-macros",
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "tokio-io-timeout"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bd86198d9ee903fedd2f9a2e72014287c0d9167e4ae43b5853007205dda1b76"
-dependencies = [
- "pin-project-lite",
- "tokio",
-]
-
 [[package]]
 name = "tokio-macros"
 version = "2.6.0"
@@ -4764,7 +4581,7 @@ checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -4814,24 +4631,22 @@ dependencies = [
 
 [[package]]
 name = "tonic"
-version = "0.9.2"
+version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3082666a3a6433f7f511c7192923fa1fe07c69332d3c6a2e6bb040b569199d5a"
+checksum = "fec7c61a0695dc1887c1b53952990f3ad2e3a31453e1f49f10e75424943a93ec"
 dependencies = [
  "async-trait",
- "axum",
- "base64 0.21.7",
+ "base64",
  "bytes",
- "futures-core",
- "futures-util",
- "h2 0.3.27",
- "http 0.2.12",
- "http-body 0.4.6",
- "hyper 0.14.32",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
  "hyper-timeout",
+ "hyper-util",
  "percent-encoding",
  "pin-project",
- "prost",
+ "sync_wrapper",
  "tokio",
  "tokio-stream",
  "tower",
@@ -4840,19 +4655,29 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "tonic-prost"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a55376a0bbaa4975a3f10d009ad763d8f4108f067c7c2e74f3001fb49778d309"
+dependencies = [
+ "bytes",
+ "prost",
+ "tonic",
+]
+
 [[package]]
 name = "tower"
-version = "0.4.13"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
 dependencies = [
  "futures-core",
  "futures-util",
- "indexmap 1.9.3",
- "pin-project",
+ "indexmap",
  "pin-project-lite",
- "rand 0.8.5",
  "slab",
+ "sync_wrapper",
  "tokio",
  "tokio-util",
  "tower-layer",
@@ -4860,6 +4685,24 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "tower-http"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
+dependencies = [
+ "bitflags 2.11.0",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "iri-string",
+ "pin-project-lite",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
 [[package]]
 name = "tower-layer"
 version = "0.3.3"
@@ -4891,7 +4734,7 @@ checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -4917,9 +4760,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.22"
+version = "0.3.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
+checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
 dependencies = [
  "matchers",
  "nu-ansi-term",
@@ -4980,6 +4823,12 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
 
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
 [[package]]
 name = "unit-prefix"
 version = "0.5.2"
@@ -5026,12 +4875,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "urlencoding"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
-
 [[package]]
 name = "utf8_iter"
 version = "1.0.4"
@@ -5046,12 +4889,12 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.19.0"
+version = "1.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2e054861b4bd027cd373e18e8d8d8e6548085000e41290d95ce0c373a654b4a"
+checksum = "5ac8b6f42ead25368cf5b098aeb3dc8a1a2c05a3eee8a9a1a68c640edbfc79d9"
 dependencies = [
  "atomic",
- "getrandom 0.3.4",
+ "getrandom 0.4.2",
  "js-sys",
  "wasm-bindgen",
 ]
@@ -5117,7 +4960,16 @@ version = "1.0.1+wasi-0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
 dependencies = [
- "wit-bindgen",
+ "wit-bindgen 0.46.0",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen 0.51.0",
 ]
 
 [[package]]
@@ -5131,9 +4983,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.106"
+version = "0.2.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
+checksum = "0551fc1bb415591e3372d0bc4780db7e587d84e2a7e79da121051c5c4b89d0b0"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -5144,22 +4996,19 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.56"
+version = "0.4.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "836d9622d604feee9e5de25ac10e3ea5f2d65b41eac0d9ce72eb5deae707ce7c"
+checksum = "03623de6905b7206edd0a75f69f747f134b7f0a2323392d664448bf2d3c5d87e"
 dependencies = [
- "cfg-if",
  "js-sys",
- "once_cell",
  "wasm-bindgen",
- "web-sys",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.106"
+version = "0.2.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
+checksum = "7fbdf9a35adf44786aecd5ff89b4563a90325f9da0923236f6104e603c7e86be"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -5167,31 +5016,65 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.106"
+version = "0.2.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
+checksum = "dca9693ef2bab6d4e6707234500350d8dad079eb508dca05530c85dc3a529ff2"
 dependencies = [
  "bumpalo",
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.106"
+version = "0.2.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
+checksum = "39129a682a6d2d841b6c429d0c51e5cb0ed1a03829d8b3d1e69a011e62cb3d3b"
 dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.11.0",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+]
+
 [[package]]
 name = "web-sys"
-version = "0.3.83"
+version = "0.3.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac"
+checksum = "cd70027e39b12f0849461e08ffc50b9cd7688d942c1c8e3c7b22273236b4dd0a"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -5281,11 +5164,13 @@ dependencies = [
 
 [[package]]
 name = "whoami"
-version = "2.0.1"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80a0d55c8d8f68772be4533e238da83f3a7adada2a85f2c3059099e5f054ebc4"
+checksum = "d6a5b12f9df4f978d2cfdb1bd3bac52433f44393342d7ee9c25f5a1c14c0f45d"
 dependencies = [
+ "libc",
  "libredox",
+ "objc2-system-configuration",
  "wasite",
  "web-sys",
 ]
@@ -5342,7 +5227,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -5353,7 +5238,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -5551,6 +5436,94 @@ version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
 
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.11.0",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.2"
@@ -5586,7 +5559,7 @@ checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
  "synstructure",
 ]
 
@@ -5607,7 +5580,7 @@ checksum = "2c7962b26b0a8685668b671ee4b54d007a67d4eaf05fda79ac0ecf41e32270f1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -5627,7 +5600,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
  "synstructure",
 ]
 
@@ -5648,7 +5621,7 @@ checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -5681,7 +5654,7 @@ checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.114",
+ "syn 2.0.117",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index b2257e9c..450b2fbe 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,75 +17,76 @@ categories = ["command-line-utilities"]
 edition = "2021"
 
 [dependencies]
-tokio = { version = "1.48.0", features = ["full"] }
+bytes = "1"
+tokio = { version = "1.50.0", features = ["full"] }
 # Use our internal russh fork with session loop fixes
 # - Development: uses local path (crates/bssh-russh)
 # - Publishing: uses crates.io version (path ignored)
-russh = { package = "bssh-russh", version = "0.56", path = "crates/bssh-russh" }
+russh = { package = "bssh-russh", version = "0.59", path = "crates/bssh-russh" }
 russh-sftp = "2.1.1"
-clap = { version = "4.5.53", features = ["derive", "env"] }
-anyhow = "1.0.100"
-thiserror = "2.0.17"
+clap = { version = "4.6.0", features = ["derive", "env"] }
+anyhow = "1.0.102"
+thiserror = "2.0.18"
 tracing = "0.1.43"
-tracing-subscriber = { version = "0.3.22", features = ["env-filter"] }
+tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_yaml = "0.9"
-futures = "0.3.31"
+futures = "0.3.32"
 async-trait = "0.1.89"
-indicatif = "0.18.3"
+indicatif = "0.18.4"
 rpassword = "7.4.0"
 directories = "6.0.0"
 dirs = "6.0"
-chrono = { version = "0.4.42", features = ["serde"] }
+chrono = { version = "0.4.44", features = ["serde"] }
 glob = "0.3.3"
-whoami = "2.0.1"
-owo-colors = "4.2.3"
+whoami = "2.1.1"
+owo-colors = "4.3.0"
 unicode-width = "0.2.2"
-terminal_size = "0.4.3"
-once_cell = "1.21.3"
+terminal_size = "0.4.4"
+once_cell = "1.21.4"
 zeroize = { version = "1.8.2", features = ["derive"] }
 secrecy = { version = "0.10.3", features = ["serde"] }
-rustyline = "17.0.2"
+rustyline = "18.0.0"
 crossterm = "0.29"
 ratatui = "0.30"
-regex = "1.12.2"
+regex = "1.12.3"
 lazy_static = "1.5"
-ctrlc = "3.5.1"
-signal-hook = "0.4.1"
-nix = { version = "0.30", features = ["fs", "poll", "process", "signal", "term"] }
+ctrlc = "3.5.2"
+signal-hook = "0.4.3"
+nix = { version = "0.31", features = ["fs", "poll", "process", "signal", "term"] }
 atty = "0.2.14"
 arrayvec = "0.7.6"
 smallvec = "1.15.1"
 lru = "0.16.2"
-uuid = { version = "1.19.0", features = ["v4"] }
+uuid = { version = "1.23.0", features = ["v4"] }
 fastrand = "2.3.0"
 tokio-util = "0.7.17"
 shell-words = "1.1.1"
 libc = "0.2"
-ipnetwork = "0.20"
-bcrypt = "0.16"
+ipnetwork = "0.21"
+bcrypt = "0.19"
 argon2 = "0.5"
 rand = "0.8"
 ssh-key = { version = "0.6", features = ["std"] }
 async-compression = { version = "0.4", features = ["tokio", "gzip"] }
 serde_json = "1.0"
-opentelemetry = "0.21"
-opentelemetry_sdk = { version = "0.21", features = ["rt-tokio", "logs"] }
-opentelemetry-otlp = { version = "0.14", features = ["grpc-tonic", "logs"] }
+opentelemetry = "0.31"
+opentelemetry_sdk = { version = "0.31", features = ["rt-tokio", "logs"] }
+opentelemetry-otlp = { version = "0.31", features = ["grpc-tonic", "logs"] }
 url = "2.5"
 tokio-rustls = "0.26"
 rustls-native-certs = "0.8"
 
 [target.'cfg(target_os = "macos")'.dependencies]
-security-framework = "3.5.1"
+security-framework = "3.7.0"
 
 [dev-dependencies]
-tempfile = "3.23.0"
-mockito = "1.7.1"
-once_cell = "1.21.3"
+tempfile = "3.27.0"
+mockito = "1.7.2"
+once_cell = "1.21.4"
 tokio-test = "0.4"
-serial_test = "3.2"
-insta = "1.44"
+serial_test = "3.4"
+insta = "1.47"
 criterion = { version = "0.8", features = ["html_reports"] }
 mockall = "0.14"
 
diff --git a/benches/large_output_benchmark.rs b/benches/large_output_benchmark.rs
index 9f07bdf5..5cb49b80 100644
--- a/benches/large_output_benchmark.rs
+++ b/benches/large_output_benchmark.rs
@@ -24,10 +24,10 @@ use bssh::executor::{MultiNodeStreamManager, NodeStream};
 use bssh::node::Node;
 use bssh::ssh::tokio_client::CommandOutput;
 use bssh::ui::tui::app::TuiApp;
+use bytes::Bytes;
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ratatui::backend::TestBackend;
 use ratatui::Terminal;
-use russh::CryptoVec;
 use std::hint::black_box;
 use tokio::runtime::Runtime;
 use tokio::sync::mpsc;
@@ -65,7 +65,7 @@ fn bench_large_output_single_stream(c: &mut Criterion) {
 
                         // Send data in 32KB chunks (typical SSH packet size)
                         let chunk_size = 32 * 1024;
-                        let chunk = CryptoVec::from(vec![b'x'; chunk_size.min(size)]);
+                        let chunk = Bytes::from(vec![b'x'; chunk_size.min(size)]);
                         let num_chunks = size.div_ceil(chunk_size);
 
                         for _ in 0..num_chunks {
@@ -110,7 +110,7 @@ fn bench_rolling_buffer_overflow(c: &mut Criterion) {
 
                         // Send data in chunks to exceed buffer limit
                         let chunk_size = 64 * 1024; // 64KB chunks
-                        let chunk = CryptoVec::from(vec![b'x'; chunk_size]);
+                        let chunk = Bytes::from(vec![b'x'; chunk_size]);
                         let num_chunks = total_size / chunk_size;
 
                         for _ in 0..num_chunks {
@@ -162,7 +162,7 @@ fn bench_concurrent_multi_node(c: &mut Criterion) {
 
                         // Send data to all nodes
                         let data_per_node = 100 * 1024; // 100KB per node
-                        let chunk = CryptoVec::from(vec![b'x'; 1024]);
+                        let chunk = Bytes::from(vec![b'x'; 1024]);
                         let chunks_per_node = data_per_node / 1024;
 
                         for _ in 0..chunks_per_node {
@@ -214,7 +214,7 @@ fn bench_poll_all_throughput(c: &mut Criterion) {
                             senders.push(tx);
                         }
 
-                        let chunk = CryptoVec::from(vec![b'x'; chunk_size]);
+                        let chunk = Bytes::from(vec![b'x'; chunk_size]);
 
                         // Send one chunk to each node and poll
                         for tx in &senders {
@@ -304,7 +304,7 @@ fn bench_tui_render_detail(c: &mut Criterion) {
                 }
 
                 rt.block_on(async {
-                    tx.send(CommandOutput::StdOut(CryptoVec::from(
+                    tx.send(CommandOutput::StdOut(Bytes::from(
                         output.as_bytes().to_vec(),
                     )))
                     .await
diff --git a/crates/bssh-russh/Cargo.toml b/crates/bssh-russh/Cargo.toml
index 48e492c6..4c12b19d 100644
--- a/crates/bssh-russh/Cargo.toml
+++ b/crates/bssh-russh/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bssh-russh"
-version = "0.56.0"
+version = "0.59.0"
 authors = ["Jeongkyu Shin <inureyes@gmail.com>"]
 description = "Temporary fork of russh with high-frequency PTY output fix (Handle::data from spawned tasks)"
 documentation = "https://docs.rs/bssh-russh"
@@ -21,11 +21,12 @@ des = ["dep:des"]
 dsa = ["ssh-key/dsa"]
 ring = ["dep:ring"]
 rsa = ["dep:rsa", "dep:pkcs1", "ssh-key/rsa", "ssh-key/rsa-sha1"]
+serde = ["ssh-key/serde"]
 
 [dependencies]
 aes = "0.8"
 async-trait = { version = "0.1.50", optional = true }
-aws-lc-rs = { version = "1.13.1", optional = true }
+aws-lc-rs = { version = "1.16.2", optional = true }
 bitflags = "2.0"
 block-padding = { version = "0.3", features = ["std"] }
 byteorder = "1.4"
@@ -46,12 +47,12 @@ flate2 = { version = "1.0.15", optional = true }
 futures = "0.3"
 generic-array = { version = "1.3.3", features = ["compat-0_14"] }
 getrandom = { version = "0.2.15", features = ["js"] }
-hex-literal = "0.4"
+hex-literal = "1"
 hmac = "0.12"
 inout = { version = "0.1", features = ["std"] }
-libcrux-ml-kem = "0.0.4"
 log = "0.4"
 md5 = "0.7"
+ml-kem = "0.2.3"
 num-bigint = { version = "0.4.2", features = ["rand"] }
 p256 = { version = "0.13", features = ["ecdh"] }
 p384 = { version = "0.13", features = ["ecdh"] }
@@ -60,8 +61,8 @@ pbkdf2 = "0.12"
 pkcs1 = { version = "0.8.0-rc.4", optional = true }
 pkcs5 = "0.7"
 pkcs8 = { version = "0.10", features = ["pkcs5", "encryption", "std"] }
-rand_core = { version = "0.6.4", features = ["getrandom", "std"] }
-rand = "0.8"
+rand_core = { version = "=0.10.0-rc-3" }
+rand = { version = "0.9", features = ["thread_rng"] }
 ring = { version = "0.17.14", optional = true }
 rsa = { version = "0.10.0-rc.10", optional = true }
 sec1 = { version = "0.7", features = ["pkcs8", "der"] }
@@ -71,15 +72,14 @@ signature = "2.2"
 spki = "0.7"
 ssh-encoding = { version = "0.2", features = ["bytes"] }
 subtle = "2.4"
-thiserror = "1.0.30"
-tokio = { version = "1.48.0", features = ["io-util", "sync", "time", "rt-multi-thread", "net"] }
+thiserror = "2.0.18"
+tokio = { version = "1.50.0", features = ["io-util", "sync", "time", "rt-multi-thread", "net"] }
 typenum = "1.17"
 yasna = { version = "0.5.0", features = ["bit-vec", "num-bigint"], optional = true }
 zeroize = "1.7"
-home = "0.5"
 
 # Public russh crates (no modifications needed)
-russh-cryptovec = { version = "0.52.0", features = ["ssh-encoding"] }
+russh-cryptovec = { version = "0.59.0", features = ["ssh-encoding"] }
 russh-util = "0.52.0"
 
 # Use the forked ssh-key from russh
diff --git a/crates/bssh-russh/patches/handle-data-fix.patch b/crates/bssh-russh/patches/handle-data-fix.patch
index 97ee272d..d93bd8cd 100644
--- a/crates/bssh-russh/patches/handle-data-fix.patch
+++ b/crates/bssh-russh/patches/handle-data-fix.patch
@@ -1,5 +1,5 @@
---- a/src/server/session.rs	2026-01-23 18:47:48
-+++ b/src/server/session.rs	2026-01-24 03:08:34
+--- /tmp/russh-upstream-compare/russh/src/server/session.rs	2026-04-03 13:17:42
++++ /Users/inureyes/Development/backend.ai/bssh/crates/bssh-russh/src/server/session.rs	2026-04-03 13:20:54
 @@ -7,7 +7,7 @@
  use log::debug;
  use negotiation::parse_kex_algo_list;
@@ -9,12 +9,7 @@
  use tokio::sync::oneshot;
  
  use super::*;
-@@ -502,10 +502,141 @@
-         pin!(reading);
-         let mut is_reading = None;
- 
-+
-         #[allow(clippy::panic)] // false positive in macro
+@@ -513,6 +513,136 @@
          while !self.common.disconnected {
              self.common.received_data = false;
              let mut sent_keepalive = false;
diff --git a/crates/bssh-russh/src/auth.rs b/crates/bssh-russh/src/auth.rs
index 6faef1b9..e96861ca 100644
--- a/crates/bssh-russh/src/auth.rs
+++ b/crates/bssh-russh/src/auth.rs
@@ -22,9 +22,9 @@ use ssh_key::{Certificate, HashAlg, PrivateKey};
 use thiserror::Error;
 use tokio::io::{AsyncRead, AsyncWrite};
 
-use crate::CryptoVec;
 use crate::helpers::NameList;
 use crate::keys::PrivateKeyWithHashAlg;
+use crate::keys::agent::AgentIdentity;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum MethodKind {
@@ -157,12 +157,12 @@ impl AuthResult {
 pub trait Signer: Sized {
     type Error: From<crate::SendError>;
 
-    fn auth_publickey_sign(
+    fn auth_sign(
         &mut self,
-        key: &ssh_key::PublicKey,
+        key: &AgentIdentity,
         hash_alg: Option<HashAlg>,
-        to_sign: CryptoVec,
-    ) -> impl Future<Output = Result<CryptoVec, Self::Error>> + Send;
+        to_sign: Vec<u8>,
+    ) -> impl Future<Output = Result<Vec<u8>, Self::Error>> + Send;
 }
 
 #[derive(Debug, Error)]
@@ -180,12 +180,12 @@ impl<R: AsyncRead + AsyncWrite + Unpin + Send + 'static> Signer
     type Error = AgentAuthError;
 
     #[allow(clippy::manual_async_fn)]
-    fn auth_publickey_sign(
+    fn auth_sign(
         &mut self,
-        key: &ssh_key::PublicKey,
+        key: &AgentIdentity,
         hash_alg: Option<HashAlg>,
-        to_sign: CryptoVec,
-    ) -> impl Future<Output = Result<CryptoVec, Self::Error>> {
+        to_sign: Vec<u8>,
+    ) -> impl Future<Output = Result<Vec<u8>, Self::Error>> {
         async move {
             self.sign_request(key, hash_alg, to_sign)
                 .await
@@ -212,6 +212,12 @@ pub enum Method {
         key: ssh_key::PublicKey,
         hash_alg: Option<HashAlg>,
     },
+    /// Certificate-based authentication using an external signer (e.g., SSH agent).
+    /// The certificate is sent to the server, but signing is delegated to the signer.
+    FutureCertificate {
+        cert: Certificate,
+        hash_alg: Option<HashAlg>,
+    },
     KeyboardInteractive {
         submethods: String,
     },
@@ -235,9 +241,9 @@ pub enum CurrentRequest {
     #[cfg_attr(target_arch = "wasm32", allow(dead_code))]
     PublicKey {
         #[allow(dead_code)]
-        key: CryptoVec,
+        key: Vec<u8>,
         #[allow(dead_code)]
-        algo: CryptoVec,
+        algo: Vec<u8>,
         sent_pk_ok: bool,
     },
     KeyboardInteractive {
diff --git a/crates/bssh-russh/src/channels/io/tx.rs b/crates/bssh-russh/src/channels/io/tx.rs
index af9565b6..7b8a56fc 100644
--- a/crates/bssh-russh/src/channels/io/tx.rs
+++ b/crates/bssh-russh/src/channels/io/tx.rs
@@ -13,8 +13,10 @@ use tokio::sync::mpsc::error::SendError;
 use tokio::sync::mpsc::{self, OwnedPermit};
 use tokio::sync::{Mutex, Notify, OwnedMutexGuard};
 
+use bytes::Bytes;
+
 use super::ChannelMsg;
-use crate::{ChannelId, CryptoVec};
+use crate::ChannelId;
 
 type BoxedThreadsafeFuture<T> = Pin<Box<dyn Sync + Send + std::future::Future<Output = T>>>;
 type OwnedPermitFuture<S> =
@@ -112,10 +114,8 @@ where
     ) -> Poll<(ChannelMsg, NonZeroUsize)> {
         let writable = ready!(self.poll_writable(cx, buf.len()));
 
-        let mut data = CryptoVec::new_zeroed(writable.into());
         #[allow(clippy::indexing_slicing)] // Clamped to maximum `buf.len()` with `.poll_writable`
-        data.copy_from_slice(&buf[..writable.into()]);
-        data.resize(writable.into());
+        let data = Bytes::copy_from_slice(&buf[..writable.into()]);
 
         let msg = match self.ext {
             None => ChannelMsg::Data { data },
diff --git a/crates/bssh-russh/src/channels/mod.rs b/crates/bssh-russh/src/channels/mod.rs
index afce6b0a..f16406c5 100644
--- a/crates/bssh-russh/src/channels/mod.rs
+++ b/crates/bssh-russh/src/channels/mod.rs
@@ -1,10 +1,11 @@
 use std::sync::Arc;
 
+use bytes::Bytes;
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio::sync::mpsc::{Receiver, Sender};
 use tokio::sync::{Mutex, Notify};
 
-use crate::{ChannelId, ChannelOpenFailure, CryptoVec, Error, Pty, Sig};
+use crate::{ChannelId, ChannelOpenFailure, Error, Pty, Sig};
 
 pub mod io;
 
@@ -24,10 +25,10 @@ pub enum ChannelMsg {
         window_size: u32,
     },
     Data {
-        data: CryptoVec,
+        data: Bytes,
     },
     ExtendedData {
-        data: CryptoVec,
+        data: Bytes,
         ext: u32,
     },
     Eof,
diff --git a/crates/bssh-russh/src/cipher/benchmark.rs b/crates/bssh-russh/src/cipher/benchmark.rs
index 115b9a60..16193f4a 100644
--- a/crates/bssh-russh/src/cipher/benchmark.rs
+++ b/crates/bssh-russh/src/cipher/benchmark.rs
@@ -1,11 +1,12 @@
 #![allow(clippy::unwrap_used)]
 use criterion::*;
-use rand::RngCore;
+use rand::TryRngCore;
+use std::hint;
 
 pub fn bench(c: &mut Criterion) {
-    let mut rand_generator = black_box(rand::rngs::OsRng {});
+    let mut rand_generator = hint::black_box(rand::rngs::OsRng {});
 
-    let mut packet_length = black_box(vec![0u8; 4]);
+    let mut packet_length = hint::black_box(vec![0u8; 4]);
 
     for cipher_name in [super::CHACHA20_POLY1305, super::AES_256_GCM] {
         let cipher = super::CIPHERS.get(&cipher_name).unwrap();
@@ -26,7 +27,7 @@ pub fn bench(c: &mut Criterion) {
             group.bench_function(format!("Block size: {size}"), |b| {
                 b.iter_with_setup(
                     || {
-                        let mut in_out = black_box(vec![0u8; size]);
+                        let mut in_out = hint::black_box(vec![0u8; size]);
                         rand_generator.try_fill_bytes(&mut in_out).unwrap();
                         rand_generator.try_fill_bytes(&mut packet_length).unwrap();
                         in_out
diff --git a/crates/bssh-russh/src/cipher/block.rs b/crates/bssh-russh/src/cipher/block.rs
index 054acd8b..e321ec99 100644
--- a/crates/bssh-russh/src/cipher/block.rs
+++ b/crates/bssh-russh/src/cipher/block.rs
@@ -21,13 +21,17 @@ use rand::RngCore;
 
 use super::super::Error;
 use super::PACKET_LENGTH_LEN;
+use crate::keys::key::safe_rng;
 use crate::mac::{Mac, MacAlgorithm};
 
 // Allow deprecated generic-array 0.14 usage until RustCrypto crates (cipher, digest, etc.)
 // upgrade to generic-array 1.x. Remove this when dependencies no longer use 0.14.
 #[allow(deprecated)]
 fn new_cipher_from_slices<C: KeyIvInit>(k: &[u8], n: &[u8]) -> C {
-    C::new(GenericArray_0_14::from_slice(k), GenericArray_0_14::from_slice(n))
+    C::new(
+        GenericArray_0_14::from_slice(k),
+        GenericArray_0_14::from_slice(n),
+    )
 }
 
 pub struct SshBlockCipher<C: BlockStreamCipher + KeySizeUser + IvSizeUser>(pub PhantomData<C>);
@@ -177,7 +181,7 @@ impl<C: BlockStreamCipher + KeySizeUser + IvSizeUser> super::SealingKey for Seal
     }
 
     fn fill_padding(&self, padding_out: &mut [u8]) {
-        rand::thread_rng().fill_bytes(padding_out);
+        safe_rng().fill_bytes(padding_out);
     }
 
     fn tag_len(&self) -> usize {
diff --git a/crates/bssh-russh/src/cipher/gcm.rs b/crates/bssh-russh/src/cipher/gcm.rs
index 9855133c..5c4d4260 100644
--- a/crates/bssh-russh/src/cipher/gcm.rs
+++ b/crates/bssh-russh/src/cipher/gcm.rs
@@ -20,8 +20,8 @@ use std::convert::TryInto;
 #[cfg(feature = "aws-lc-rs")]
 use aws_lc_rs::{
     aead::{
-        Aad, Algorithm, BoundKey, Nonce as AeadNonce, NonceSequence, OpeningKey as AeadOpeningKey,
-        SealingKey as AeadSealingKey, UnboundKey, NONCE_LEN,
+        Aad, Algorithm, BoundKey, NONCE_LEN, Nonce as AeadNonce, NonceSequence,
+        OpeningKey as AeadOpeningKey, SealingKey as AeadSealingKey, UnboundKey,
     },
     error::Unspecified,
 };
@@ -29,13 +29,14 @@ use rand::RngCore;
 #[cfg(all(not(feature = "aws-lc-rs"), feature = "ring"))]
 use ring::{
     aead::{
-        Aad, Algorithm, BoundKey, Nonce as AeadNonce, NonceSequence, OpeningKey as AeadOpeningKey,
-        SealingKey as AeadSealingKey, UnboundKey, NONCE_LEN,
+        Aad, Algorithm, BoundKey, NONCE_LEN, Nonce as AeadNonce, NonceSequence,
+        OpeningKey as AeadOpeningKey, SealingKey as AeadSealingKey, UnboundKey,
     },
     error::Unspecified,
 };
 
 use super::super::Error;
+use crate::keys::key::safe_rng;
 use crate::mac::MacAlgorithm;
 
 pub struct GcmCipher(pub(crate) &'static Algorithm);
@@ -156,7 +157,7 @@ impl<N: NonceSequence> super::SealingKey for SealingKey<N> {
     }
 
     fn fill_padding(&self, padding_out: &mut [u8]) {
-        rand::thread_rng().fill_bytes(padding_out);
+        safe_rng().fill_bytes(padding_out);
     }
 
     fn tag_len(&self) -> usize {
diff --git a/crates/bssh-russh/src/cipher/mod.rs b/crates/bssh-russh/src/cipher/mod.rs
index 54422d79..1b10055b 100644
--- a/crates/bssh-russh/src/cipher/mod.rs
+++ b/crates/bssh-russh/src/cipher/mod.rs
@@ -230,9 +230,13 @@ pub(crate) trait SealingKey {
 
         assert!(padding_length <= u8::MAX as usize);
         buffer.buffer.push(padding_length as u8);
-        buffer.buffer.extend(payload);
-        self.fill_padding(buffer.buffer.resize_mut(padding_length));
-        buffer.buffer.resize_mut(self.tag_len());
+        buffer.buffer.extend_from_slice(payload);
+        let pad_offset = buffer.buffer.len();
+        buffer.buffer.resize(pad_offset + padding_length, 0);
+        #[allow(clippy::indexing_slicing)] // length checked
+        self.fill_padding(&mut buffer.buffer[pad_offset..]);
+        let tag_offset = buffer.buffer.len();
+        buffer.buffer.resize(tag_offset + self.tag_len(), 0);
 
         #[allow(clippy::indexing_slicing)] // length checked
         let (plaintext, tag) =
@@ -260,7 +264,7 @@ pub(crate) async fn read<R: AsyncRead + Unpin>(
         {
             let seqn = buffer.seqn.0;
             buffer.buffer.clear();
-            buffer.buffer.extend(&len);
+            buffer.buffer.extend_from_slice(&len);
             trace!("reading, seqn = {seqn:?}");
             let len = cipher.decrypt_packet_length(seqn, &len);
             let len = BigEndian::read_u32(&len) as usize;
@@ -274,7 +278,7 @@ pub(crate) async fn read<R: AsyncRead + Unpin>(
         }
     }
 
-    buffer.buffer.resize(buffer.len + 4);
+    buffer.buffer.resize(buffer.len + 4, 0);
     trace!("read_exact {:?}", buffer.len + 4);
 
     let l = cipher.packet_length_to_read_for_block_length();
@@ -299,7 +303,7 @@ pub(crate) async fn read<R: AsyncRead + Unpin>(
     buffer.len = 0;
 
     // Remove the padding
-    buffer.buffer.resize(plaintext_end + 4);
+    buffer.buffer.resize(plaintext_end + 4, 0);
 
     Ok(plaintext_end + 4)
 }
@@ -307,9 +311,17 @@ pub(crate) async fn read<R: AsyncRead + Unpin>(
 pub(crate) const PACKET_LENGTH_LEN: usize = 4;
 
 const MINIMUM_PACKET_LEN: usize = 16;
-const MAXIMUM_PACKET_LEN: usize = 256 * 1024;
-
+// Keep the transport limit aligned with the 256 KiB channel packet baseline.
+const MAXIMUM_PACKET_LEN_BASELINE: usize = 256 * 1024;
+const CHANNEL_DATA_PACKET_OVERHEAD: usize = 1 + 4 + 4;
+const CHANNEL_EXTENDED_DATA_PACKET_OVERHEAD: usize = CHANNEL_DATA_PACKET_OVERHEAD + 4;
 const PADDING_LENGTH_LEN: usize = 1;
+// SSH requires at least four bytes of padding; with 16-byte blocks, that means
+// a full-size channel packet can need up to 19 bytes of transport padding.
+const MAXIMUM_PADDING_LEN: usize = 19;
+const MAXIMUM_PACKET_LEN_HEADROOM: usize =
+    PADDING_LENGTH_LEN + CHANNEL_EXTENDED_DATA_PACKET_OVERHEAD + MAXIMUM_PADDING_LEN;
+const MAXIMUM_PACKET_LEN: usize = MAXIMUM_PACKET_LEN_BASELINE + MAXIMUM_PACKET_LEN_HEADROOM;
 
 #[cfg(feature = "_bench")]
 pub mod benchmark;
diff --git a/crates/bssh-russh/src/client/encrypted.rs b/crates/bssh-russh/src/client/encrypted.rs
index cd2e2c65..900847a8 100644
--- a/crates/bssh-russh/src/client/encrypted.rs
+++ b/crates/bssh-russh/src/client/encrypted.rs
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-use std::cell::RefCell;
 use std::convert::TryInto;
 use std::ops::Deref;
 use std::str::FromStr;
@@ -26,19 +25,15 @@ use super::IncomingSshPacket;
 use crate::auth::AuthRequest;
 use crate::cert::PublicKeyOrCertificate;
 use crate::client::{Handler, Msg, Prompt, Reply, Session};
-use crate::helpers::{sign_with_hash_alg, AlgorithmExt, EncodedExt, NameList};
+use crate::helpers::{AlgorithmExt, EncodedExt, NameList, sign_with_hash_alg};
 use crate::keys::key::parse_public_key;
 use crate::parsing::{ChannelOpenConfirmation, ChannelType, OpenChannelMessage};
 use crate::session::{Encrypted, EncryptedState, GlobalRequestResponse};
 use crate::{
-    auth, map_err, msg, Channel, ChannelId, ChannelMsg, ChannelOpenFailure, ChannelParams, CryptoVec, Error,
-    MethodSet, Sig,
+    Channel, ChannelId, ChannelMsg, ChannelOpenFailure, ChannelParams, Error, MethodSet, Sig, auth,
+    map_err, msg,
 };
 
-thread_local! {
-    static SIGNATURE_BUFFER: RefCell<CryptoVec> = RefCell::new(CryptoVec::new());
-}
-
 impl Session {
     pub(crate) async fn client_read_encrypted<H: Handler>(
         &mut self,
@@ -109,7 +104,9 @@ impl Session {
                                 .send(Reply::AuthSuccess)
                                 .map_err(|_| crate::Error::SendError)?;
                             enc.state = EncryptedState::InitCompression;
-                            enc.server_compression.init_decompress(&mut enc.decompress);
+                            if enc.server_compression.is_deferred() {
+                                enc.server_compression.init_decompress(&mut enc.decompress);
+                            }
                             return Ok(());
                         }
                         Some((&msg::USERAUTH_BANNER, mut r)) => {
@@ -123,7 +120,9 @@ impl Session {
                             let remaining_methods: MethodSet =
                                 (&map_err!(NameList::decode(&mut r))?).into();
                             let partial_success = map_err!(u8::decode(&mut r))? != 0;
-                            debug!("remaining methods {remaining_methods:?}, partial success {partial_success:?}");
+                            debug!(
+                                "remaining methods {remaining_methods:?}, partial success {partial_success:?}"
+                            );
                             auth_request.methods = remaining_methods.clone();
 
                             let no_more_methods = auth_request.methods.is_empty();
@@ -188,7 +187,7 @@ impl Session {
                                 let responses = loop {
                                     match self.receiver.recv().await {
                                         Some(Msg::AuthInfoResponse { responses }) => {
-                                            break responses
+                                            break responses;
                                         }
                                         None => return Err(crate::Error::RecvError.into()),
                                         _ => {}
@@ -229,14 +228,44 @@ impl Session {
                                         &mut self.common.buffer,
                                     )?;
                                     let len = self.common.buffer.len();
-                                    let buf = std::mem::replace(
-                                        &mut self.common.buffer,
-                                        CryptoVec::new(),
-                                    );
+                                    let buf = std::mem::take(&mut self.common.buffer);
 
                                     self.sender
                                         .send(Reply::SignRequest { key, data: buf })
                                         .map_err(|_| crate::Error::SendError)?;
+                                    self.common.buffer = loop {
+                                        match self.receiver.recv().await {
+                                            Some(Msg::Signed { data }) => break data[..].to_vec(),
+                                            None => return Err(crate::Error::RecvError.into()),
+                                            _ => {}
+                                        }
+                                    };
+                                    if self.common.buffer.len() != len {
+                                        // The buffer was modified.
+                                        push_packet!(enc.write, {
+                                            #[allow(clippy::indexing_slicing)] // length checked
+                                            enc.write.extend_from_slice(&self.common.buffer[i..]);
+                                        })
+                                    }
+                                }
+                                Some(auth::Method::FutureCertificate { cert, hash_alg }) => {
+                                    debug!("certificate");
+                                    self.common.buffer.clear();
+                                    let i = enc.client_make_to_sign(
+                                        &self.common.auth_user,
+                                        &PublicKeyOrCertificate::Certificate(cert.clone()),
+                                        &mut self.common.buffer,
+                                    )?;
+                                    let len = self.common.buffer.len();
+                                    let buf = std::mem::take(&mut self.common.buffer);
+
+                                    self.sender
+                                        .send(Reply::SignRequestCert {
+                                            cert,
+                                            hash_alg,
+                                            data: buf,
+                                        })
+                                        .map_err(|_| crate::Error::SendError)?;
                                     self.common.buffer = loop {
                                         match self.receiver.recv().await {
                                             Some(Msg::Signed { data }) => break data,
@@ -365,6 +394,12 @@ impl Session {
                     // will not be released.
                     enc.close(channel_num)?;
                 }
+                // Forward the close to the channel before removing it, so that
+                // consumers waiting on `Channel::wait()` receive an explicit
+                // `ChannelMsg::Close` instead of just seeing `None`.
+                if let Some(chan) = self.channels.get(&channel_num) {
+                    let _ = chan.send(ChannelMsg::Close).await;
+                }
                 self.channels.remove(&channel_num);
                 client.channel_close(channel_num, self).await
             }
@@ -413,11 +448,7 @@ impl Session {
                 }
 
                 if let Some(chan) = self.channels.get(&channel_num) {
-                    let _ = chan
-                        .send(ChannelMsg::Data {
-                            data: CryptoVec::from_slice(&data),
-                        })
-                        .await;
+                    let _ = chan.send(ChannelMsg::Data { data: data.clone() }).await;
                 }
 
                 client.data(channel_num, &data, self).await
@@ -442,7 +473,7 @@ impl Session {
                     let _ = chan
                         .send(ChannelMsg::ExtendedData {
                             ext: extended_code,
-                            data: CryptoVec::from_slice(&data),
+                            data: data.clone(),
                         })
                         .await;
                 }
@@ -506,10 +537,12 @@ impl Session {
                             if let Some(ref mut enc) = self.common.encrypted {
                                 trace!("Received channel keep alive message: {req:?}",);
                                 self.common.wants_reply = false;
-                                push_packet!(enc.write, {
-                                    map_err!(msg::CHANNEL_SUCCESS.encode(&mut enc.write))?;
-                                    map_err!(channel_num.encode(&mut enc.write))?;
-                                });
+                                if let Some(ch) = enc.channels.get(&channel_num) {
+                                    push_packet!(enc.write, {
+                                        map_err!(msg::CHANNEL_SUCCESS.encode(&mut enc.write))?;
+                                        map_err!(ch.recipient_channel.encode(&mut enc.write))?;
+                                    });
+                                }
                             }
                         } else {
                             warn!("Received keepalive without reply request!");
@@ -521,10 +554,12 @@ impl Session {
                         if wants_reply == 1 {
                             if let Some(ref mut enc) = self.common.encrypted {
                                 self.common.wants_reply = false;
-                                push_packet!(enc.write, {
-                                    map_err!(msg::CHANNEL_FAILURE.encode(&mut enc.write))?;
-                                    map_err!(channel_num.encode(&mut enc.write))?;
-                                })
+                                if let Some(ch) = enc.channels.get(&channel_num) {
+                                    push_packet!(enc.write, {
+                                        map_err!(msg::CHANNEL_FAILURE.encode(&mut enc.write))?;
+                                        map_err!(ch.recipient_channel.encode(&mut enc.write))?;
+                                    })
+                                }
                             }
                         }
                         info!("Unknown channel request {req:?} {wants_reply:?}",);
@@ -551,8 +586,10 @@ impl Session {
                 }
                 if let Some(chan) = self.channels.get(&channel_num) {
                     chan.window_size().update(new_size).await;
-
-                    let _ = chan.send(ChannelMsg::WindowAdjusted { new_size }).await;
+                    // Use try_send to avoid blocking the session loop when channel buffer is full.
+                    // WindowAdjusted is informational - the critical side effect (updating
+                    // WindowSizeRef and notifying ChannelTx) already happens in update().
+                    let _ = chan.try_send(ChannelMsg::WindowAdjusted { new_size });
                 }
                 client.window_adjusted(channel_num, new_size, self).await
             }
@@ -861,9 +898,7 @@ impl Session {
                 }
                 EncryptedState::InitCompression | EncryptedState::Authenticated => false,
             };
-            debug!(
-                "write_auth_request_if_needed: is_waiting = {is_waiting:?}"
-            );
+            debug!("write_auth_request_if_needed: is_waiting = {is_waiting:?}");
             if is_waiting {
                 enc.write_auth_request(user, &meth)?;
                 let auth_request = AuthRequest::new(&meth);
@@ -940,6 +975,18 @@ impl Encrypted {
                     key.to_bytes()?.as_slice().encode(&mut self.write)?;
                     true
                 }
+                auth::Method::FutureCertificate { ref cert, .. } => {
+                    user.as_bytes().encode(&mut self.write)?;
+                    "ssh-connection".encode(&mut self.write)?;
+                    "publickey".encode(&mut self.write)?;
+                    self.write.push(0); // This is a probe
+
+                    cert.algorithm()
+                        .to_certificate_type()
+                        .encode(&mut self.write)?;
+                    cert.to_bytes()?.as_slice().encode(&mut self.write)?;
+                    true
+                }
                 auth::Method::KeyboardInteractive { ref submethods } => {
                     debug!("Keyboard interactive");
                     user.as_bytes().encode(&mut self.write)?;
@@ -957,7 +1004,7 @@ impl Encrypted {
         &mut self,
         user: &str,
         key: &PublicKeyOrCertificate,
-        buffer: &mut CryptoVec,
+        buffer: &mut Vec<u8>,
     ) -> Result<usize, crate::Error> {
         buffer.clear();
         self.session_id.as_ref().encode(buffer)?;
@@ -986,7 +1033,7 @@ impl Encrypted {
         &mut self,
         user: &str,
         method: &auth::Method,
-        buffer: &mut CryptoVec,
+        buffer: &mut Vec<u8>,
     ) -> Result<(), crate::Error> {
         match method {
             auth::Method::PublicKey { key } => {
@@ -998,7 +1045,7 @@ impl Encrypted {
 
                 push_packet!(self.write, {
                     #[allow(clippy::indexing_slicing)] // length checked
-                    self.write.extend(&buffer[i0..]);
+                    self.write.extend_from_slice(&buffer[i0..]);
                 })
             }
             auth::Method::OpenSshCertificate { key, cert } => {
@@ -1015,7 +1062,7 @@ impl Encrypted {
 
                 push_packet!(self.write, {
                     #[allow(clippy::indexing_slicing)] // length checked
-                    self.write.extend(&buffer[i0..]);
+                    self.write.extend_from_slice(&buffer[i0..]);
                 })
             }
             _ => {}
diff --git a/crates/bssh-russh/src/client/kex.rs b/crates/bssh-russh/src/client/kex.rs
index fbda79ea..73512833 100644
--- a/crates/bssh-russh/src/client/kex.rs
+++ b/crates/bssh-russh/src/client/kex.rs
@@ -116,7 +116,7 @@ impl ClientKex {
 
                 let names = {
                     // read algorithms from packet.
-                    self.exchange.server_kex_init.extend(&input.buffer);
+                    self.exchange.server_kex_init.extend_from_slice(&input.buffer);
                     negotiation::Client::read_kex(
                         &input.buffer,
                         &self.config.preferred,
@@ -139,7 +139,7 @@ impl ClientKex {
                 if kex.skip_exchange() {
                     // Non-standard no-kex exchange
                     let newkeys = compute_keys(
-                        CryptoVec::new(),
+                        Vec::new(),
                         kex,
                         names.clone(),
                         self.exchange.clone(),
@@ -270,10 +270,10 @@ impl ClientKex {
                 );
 
                 let server_ephemeral = Bytes::decode(r)?;
-                self.exchange.server_ephemeral.extend(&server_ephemeral);
+                self.exchange.server_ephemeral.extend_from_slice(&server_ephemeral);
                 kex.compute_shared_secret(&self.exchange.server_ephemeral)?;
 
-                let mut pubkey_vec = CryptoVec::new();
+                let mut pubkey_vec = Vec::new();
                 server_host_key.to_bytes()?.encode(&mut pubkey_vec)?;
 
                 let exchange = &self.exchange;
@@ -346,32 +346,43 @@ impl ClientKex {
 }
 
 fn compute_keys(
-    hash: CryptoVec,
+    hash: Vec<u8>,
     kex: KexAlgorithm,
     names: Names,
     exchange: Exchange,
     session_id: Option<&CryptoVec>,
 ) -> Result<NewKeys, Error> {
-    let session_id = if let Some(session_id) = session_id {
-        session_id
-    } else {
-        &hash
+    let session_id_ref: &[u8] = match session_id {
+        Some(sid) => sid,
+        None => &hash,
     };
     // Now computing keys.
     let c = kex.compute_keys(
-        session_id,
+        session_id_ref,
         &hash,
         names.cipher,
         names.server_mac,
         names.client_mac,
         false,
     )?;
+    // The session_id stored in NewKeys is sensitive key material
+    // (used in key derivation), so keep it as CryptoVec.
+    // On initial exchange the exchange hash becomes the session_id;
+    // on rekey we already have it as CryptoVec.
+    let session_id_cv = match session_id {
+        Some(s) => s.clone(),
+        None => {
+            let mut cv = CryptoVec::new();
+            cv.extend(&hash);
+            cv
+        }
+    };
     Ok(NewKeys {
         exchange,
         names,
         kex,
         key: 0,
         cipher: c,
-        session_id: session_id.clone(),
+        session_id: session_id_cv,
     })
 }
diff --git a/crates/bssh-russh/src/client/mod.rs b/crates/bssh-russh/src/client/mod.rs
index c888f44c..e1e99565 100644
--- a/crates/bssh-russh/src/client/mod.rs
+++ b/crates/bssh-russh/src/client/mod.rs
@@ -34,6 +34,7 @@
 //!
 //! [Session]: client::Session
 
+use std::borrow::Cow;
 use std::collections::{HashMap, VecDeque};
 use std::convert::TryInto;
 use std::num::Wrapping;
@@ -68,8 +69,8 @@ use crate::session::{CommonSession, EncryptedState, GlobalRequestResponse, NewKe
 use crate::ssh_read::SshRead;
 use crate::sshbuffer::{IncomingSshPacket, PacketWriter, SSHBuffer, SshId};
 use crate::{
-    ChannelId, ChannelOpenFailure, CryptoVec, Disconnect, Error, Limits, MethodSet, Sig, auth,
-    map_err, msg, negotiation,
+    ChannelId, ChannelOpenFailure, Disconnect, Error, Limits, MethodSet, Sig, auth, map_err, msg,
+    negotiation,
 };
 
 mod encrypted;
@@ -92,7 +93,7 @@ pub struct Session {
     sender: UnboundedSender<Reply>,
     channels: HashMap<ChannelId, ChannelRef>,
     target_window_size: u32,
-    pending_reads: Vec<CryptoVec>,
+    pending_reads: Vec<Vec<u8>>,
     pending_len: u32,
     inbound_channel_sender: Sender<Msg>,
     inbound_channel_receiver: Receiver<Msg>,
@@ -117,7 +118,12 @@ enum Reply {
     ChannelOpenFailure,
     SignRequest {
         key: ssh_key::PublicKey,
-        data: CryptoVec,
+        data: Vec<u8>,
+    },
+    SignRequestCert {
+        cert: Certificate,
+        hash_alg: Option<HashAlg>,
+        data: Vec<u8>,
     },
     AuthInfoRequest {
         name: String,
@@ -137,7 +143,7 @@ pub enum Msg {
         responses: Vec<String>,
     },
     Signed {
-        data: CryptoVec,
+        data: Vec<u8>,
     },
     ChannelOpenSession {
         channel_ref: ChannelRef,
@@ -480,7 +486,69 @@ impl<H: Handler> Handle<H> {
                     });
                 }
                 Some(Reply::SignRequest { key, data }) => {
-                    let data = signer.auth_publickey_sign(&key, hash_alg, data).await;
+                    let data = signer.auth_sign(&key.into(), hash_alg, data).await;
+                    let data = match data {
+                        Ok(data) => data,
+                        Err(e) => return Err(e),
+                    };
+                    if self.sender.send(Msg::Signed { data }).await.is_err() {
+                        return Err((crate::SendError {}).into());
+                    }
+                }
+                None => {
+                    return Ok(AuthResult::Failure {
+                        remaining_methods: MethodSet::empty(),
+                        partial_success: false,
+                    });
+                }
+                _ => {}
+            }
+        }
+    }
+
+    /// Authenticate using a certificate with a custom signer that implements the
+    /// [`Signer`][auth::Signer] trait. This is for certificate-based authentication
+    /// where the signing is delegated to an external signer (e.g., SSH agent).
+    ///
+    /// For RSA certificates, you can specify the hash algorithm to use.
+    pub async fn authenticate_certificate_with<U: Into<String>, S: auth::Signer>(
+        &mut self,
+        user: U,
+        cert: Certificate,
+        hash_alg: Option<HashAlg>,
+        signer: &mut S,
+    ) -> Result<AuthResult, S::Error> {
+        let user = user.into();
+        if self
+            .sender
+            .send(Msg::Authenticate {
+                user,
+                method: auth::Method::FutureCertificate { cert, hash_alg },
+            })
+            .await
+            .is_err()
+        {
+            return Err((crate::SendError {}).into());
+        }
+        loop {
+            let reply = self.receiver.recv().await;
+            match reply {
+                Some(Reply::AuthSuccess) => return Ok(AuthResult::Success),
+                Some(Reply::AuthFailure {
+                    proceed_with_methods: remaining_methods,
+                    partial_success,
+                }) => {
+                    return Ok(AuthResult::Failure {
+                        remaining_methods,
+                        partial_success,
+                    });
+                }
+                Some(Reply::SignRequestCert {
+                    cert,
+                    hash_alg,
+                    data,
+                }) => {
+                    let data = signer.auth_sign(&cert.into(), hash_alg, data).await;
                     let data = match data {
                         Ok(data) => data,
                         Err(e) => return Err(e),
@@ -695,7 +763,7 @@ impl<H: Handler> Handle<H> {
     ///
     /// If port == 0 the server will choose a port that will be returned, returns 0 otherwise
     pub async fn tcpip_forward<A: Into<String>>(
-        &mut self,
+        &self,
         address: A,
         port: u32,
     ) -> Result<u32, crate::Error> {
@@ -747,7 +815,7 @@ impl<H: Handler> Handle<H> {
 
     // Requests the server to open a UDS forward channel
     pub async fn streamlocal_forward<A: Into<String>>(
-        &mut self,
+        &self,
         socket_path: A,
     ) -> Result<(), crate::Error> {
         let (reply_send, reply_recv) = oneshot::channel();
@@ -815,9 +883,14 @@ impl<H: Handler> Handle<H> {
     ///
     /// This is useful for server-initiated channels; for channels created by
     /// the client, prefer to use the Channel returned from the `open_*` methods.
-    pub async fn data(&self, id: ChannelId, data: CryptoVec) -> Result<(), CryptoVec> {
+    pub async fn data(
+        &self,
+        id: ChannelId,
+        data: impl Into<bytes::Bytes>,
+    ) -> Result<(), bytes::Bytes> {
+        let data = data.into();
         self.sender
-            .send(Msg::Channel(id, ChannelMsg::Data { data }))
+            .send(Msg::Channel(id, ChannelMsg::Data { data: data.clone() }))
             .await
             .map_err(|e| match e.0 {
                 Msg::Channel(_, ChannelMsg::Data { data, .. }) => data,
@@ -948,7 +1021,7 @@ where
             config,
             wants_reply: false,
             disconnected: false,
-            buffer: CryptoVec::new(),
+            buffer: Vec::new(),
             strict_kex: false,
             alive_timeouts: 0,
             received_data: false,
@@ -990,7 +1063,7 @@ async fn start_reading<R: AsyncRead + Unpin>(
 impl Session {
     fn maybe_decompress(&mut self, buffer: &SSHBuffer) -> Result<IncomingSshPacket, Error> {
         if let Some(ref mut enc) = self.common.encrypted {
-            let mut decomp = CryptoVec::new();
+            let mut decomp = Vec::new();
             Ok(IncomingSshPacket {
                 #[allow(clippy::indexing_slicing)] // length checked
                 buffer: enc.decompress.decompress(
@@ -1138,13 +1211,17 @@ impl Session {
                     reading.set(start_reading(stream_read, buffer, opening_cipher));
                 }
                 () = &mut keepalive_timer => {
-                    self.common.alive_timeouts = self.common.alive_timeouts.saturating_add(1);
-                    if self.common.config.keepalive_max != 0 && self.common.alive_timeouts > self.common.config.keepalive_max {
-                        debug!("Timeout, server not responding to keepalives");
-                        return Err(crate::Error::KeepaliveTimeout.into());
+                    if let Some(ref mut enc) = self.common.encrypted {
+                        if matches!(enc.state, EncryptedState::Authenticated) {
+                            self.common.alive_timeouts = self.common.alive_timeouts.saturating_add(1);
+                            if self.common.config.keepalive_max != 0 && self.common.alive_timeouts > self.common.config.keepalive_max {
+                                debug!("Timeout, server not responding to keepalives");
+                                return Err(crate::Error::KeepaliveTimeout.into());
+                            }
+                            sent_keepalive = true;
+                            self.send_keepalive(true)?;
+                        }
                     }
-                    sent_keepalive = true;
-                    self.send_keepalive(true)?;
                 }
                 () = &mut inactivity_timer => {
                     debug!("timeout");
@@ -1188,8 +1265,10 @@ impl Session {
 
             if let Some(ref mut enc) = self.common.encrypted {
                 if let EncryptedState::InitCompression = enc.state {
-                    enc.client_compression
-                        .init_compress(self.common.packet_writer.compress());
+                    if enc.client_compression.is_deferred() {
+                        enc.client_compression
+                            .init_compress(self.common.packet_writer.compress());
+                    }
                     enc.state = EncryptedState::Authenticated;
                 }
             }
@@ -1692,11 +1771,12 @@ pub struct Config {
 impl Default for Config {
     fn default() -> Config {
         Config {
-            client_id: SshId::Standard(format!(
-                "SSH-2.0-{}_{}",
+            client_id: SshId::Standard(Cow::Borrowed(concat!(
+                "SSH-2.0-",
                 env!("CARGO_PKG_NAME"),
+                "_",
                 env!("CARGO_PKG_VERSION")
-            )),
+            ))),
             limits: Limits::default(),
             window_size: 2097152,
             maximum_packet_size: 32768,
diff --git a/crates/bssh-russh/src/client/session.rs b/crates/bssh-russh/src/client/session.rs
index 29fc4550..3a5ed1a1 100644
--- a/crates/bssh-russh/src/client/session.rs
+++ b/crates/bssh-russh/src/client/session.rs
@@ -4,7 +4,7 @@ use tokio::sync::oneshot;
 
 use crate::client::Session;
 use crate::session::EncryptedState;
-use crate::{map_err, msg, ChannelId, CryptoVec, Disconnect, Pty, Sig};
+use crate::{map_err, msg, ChannelId, Disconnect, Pty, Sig};
 
 impl Session {
     fn channel_open_generic<F>(
@@ -13,7 +13,7 @@ impl Session {
         write_suffix: F,
     ) -> Result<ChannelId, crate::Error>
     where
-        F: FnOnce(&mut CryptoVec) -> Result<(), crate::Error>,
+        F: FnOnce(&mut Vec<u8>) -> Result<(), crate::Error>,
     {
         let result = if let Some(ref mut enc) = self.common.encrypted {
             match enc.state {
@@ -442,7 +442,7 @@ impl Session {
         Ok(())
     }
 
-    pub fn data(&mut self, channel: ChannelId, data: CryptoVec) -> Result<(), crate::Error> {
+    pub fn data(&mut self, channel: ChannelId, data: impl Into<bytes::Bytes>) -> Result<(), crate::Error> {
         if let Some(ref mut enc) = self.common.encrypted {
             enc.data(channel, data, self.kex.active())
         } else {
@@ -470,7 +470,7 @@ impl Session {
         &mut self,
         channel: ChannelId,
         ext: u32,
-        data: CryptoVec,
+        data: impl Into<bytes::Bytes>,
     ) -> Result<(), crate::Error> {
         if let Some(ref mut enc) = self.common.encrypted {
             enc.extended_data(channel, ext, data, self.kex.active())
diff --git a/crates/bssh-russh/src/client/test.rs b/crates/bssh-russh/src/client/test.rs
index 566f898c..54746718 100644
--- a/crates/bssh-russh/src/client/test.rs
+++ b/crates/bssh-russh/src/client/test.rs
@@ -4,16 +4,16 @@ mod tests {
     use std::sync::{Arc, Mutex};
 
     use log::debug;
-    use rand_core::OsRng;
     use ssh_key::PrivateKey;
     use tokio::net::TcpListener;
 
     // Import client types directly since we're in the client module
-    use crate::client::{connect, Config, Handler};
+    use crate::client::{Config, Handler, connect};
     use crate::keys::PrivateKeyWithHashAlg;
+    use crate::keys::ssh_key::rand_core::OsRng;
     use crate::server::{self, Auth, Handler as ServerHandler, Server, Session};
     use crate::{ChannelId, SshId}; // Import directly from crate root
-    use crate::{CryptoVec, Error};
+    use crate::Error;
 
     #[derive(Clone)]
     struct TestServer {
@@ -62,7 +62,7 @@ mod tests {
             session: &mut Session,
         ) -> Result<(), Self::Error> {
             debug!("server received data: {:?}", std::str::from_utf8(data));
-            session.data(channel, CryptoVec::from_slice(data))?;
+            session.data(channel, data.to_vec())?;
             Ok(())
         }
     }
@@ -87,7 +87,7 @@ mod tests {
         // Configure the server
         let mut config = server::Config::default();
         config.auth_rejection_time = std::time::Duration::from_secs(1);
-        config.server_id = SshId::Standard("SSH-1.99-CustomServer_1.0".to_string());
+        config.server_id = SshId::Standard("SSH-1.99-CustomServer_1.0".into());
         config.inactivity_timeout = None;
         config
             .keys
diff --git a/crates/bssh-russh/src/compression.rs b/crates/bssh-russh/src/compression.rs
index d6eec087..ec3eff60 100644
--- a/crates/bssh-russh/src/compression.rs
+++ b/crates/bssh-russh/src/compression.rs
@@ -8,6 +8,8 @@ pub enum Compression {
     None,
     #[cfg(feature = "flate2")]
     Zlib,
+    #[cfg(feature = "flate2")]
+    ZlibOpenSSH,
 }
 
 #[derive(Debug)]
@@ -67,34 +69,55 @@ pub const ALL_COMPRESSION_ALGORITHMS: &[&Name] = &[
 #[cfg(feature = "flate2")]
 impl Compression {
     pub fn new(name: &Name) -> Self {
-        if name == &ZLIB || name == &ZLIB_LEGACY {
+        if name == &ZLIB {
             Compression::Zlib
+        } else if name == &ZLIB_LEGACY {
+            Compression::ZlibOpenSSH
         } else {
             Compression::None
         }
     }
 
     pub fn init_compress(&self, comp: &mut Compress) {
-        if let Compression::Zlib = *self {
-            if let Compress::Zlib(ref mut c) = *comp {
-                c.reset()
-            } else {
-                *comp = Compress::Zlib(flate2::Compress::new(flate2::Compression::fast(), true))
+        match *self {
+            Compression::Zlib | Compression::ZlibOpenSSH => {
+                if let Compress::Zlib(ref mut c) = *comp {
+                    c.reset()
+                } else {
+                    *comp =
+                        Compress::Zlib(flate2::Compress::new(flate2::Compression::fast(), true))
+                }
+            }
+            Compression::None => {
+                *comp = Compress::None;
             }
-        } else {
-            *comp = Compress::None
         }
     }
 
     pub fn init_decompress(&self, comp: &mut Decompress) {
-        if let Compression::Zlib = *self {
-            if let Decompress::Zlib(ref mut c) = *comp {
-                c.reset(true)
-            } else {
-                *comp = Decompress::Zlib(flate2::Decompress::new(true))
+        match *self {
+            Compression::Zlib | Compression::ZlibOpenSSH => {
+                if let Decompress::Zlib(ref mut c) = *comp {
+                    c.reset(true)
+                } else {
+                    *comp = Decompress::Zlib(flate2::Decompress::new(true))
+                }
             }
-        } else {
-            *comp = Decompress::None
+            Compression::None => {
+                *comp = Decompress::None;
+            }
+        }
+    }
+}
+
+impl Compression {
+    /// Returns true if compression should be deferred until after authentication.
+    /// "zlib@openssh.com" defers; RFC 4253 "zlib" does not.
+    pub fn is_deferred(&self) -> bool {
+        match self {
+            #[cfg(feature = "flate2")]
+            Compression::ZlibOpenSSH => true,
+            _ => false,
         }
     }
 }
@@ -115,7 +138,7 @@ impl Compress {
     pub fn compress<'a>(
         &mut self,
         input: &'a [u8],
-        _: &'a mut russh_cryptovec::CryptoVec,
+        _: &'a mut Vec<u8>,
     ) -> Result<&'a [u8], crate::Error> {
         Ok(input)
     }
@@ -126,7 +149,7 @@ impl Decompress {
     pub fn decompress<'a>(
         &mut self,
         input: &'a [u8],
-        _: &'a mut russh_cryptovec::CryptoVec,
+        _: &'a mut Vec<u8>,
     ) -> Result<&'a [u8], crate::Error> {
         Ok(input)
     }
@@ -137,7 +160,7 @@ impl Compress {
     pub fn compress<'a>(
         &mut self,
         input: &'a [u8],
-        output: &'a mut russh_cryptovec::CryptoVec,
+        output: &'a mut Vec<u8>,
     ) -> Result<&'a [u8], crate::Error> {
         match *self {
             Compress::None => Ok(input),
@@ -145,7 +168,7 @@ impl Compress {
                 output.clear();
                 let n_in = z.total_in() as usize;
                 let n_out = z.total_out() as usize;
-                output.resize(input.len() + 10);
+                output.resize(input.len() + 10, 0);
                 let flush = flate2::FlushCompress::Partial;
                 loop {
                     let n_in_ = z.total_in() as usize - n_in;
@@ -154,7 +177,7 @@ impl Compress {
                     let c = z.compress(&input[n_in_..], &mut output[n_out_..], flush)?;
                     match c {
                         flate2::Status::BufError => {
-                            output.resize(output.len() * 2);
+                            output.resize(output.len() * 2, 0);
                         }
                         _ => break,
                     }
@@ -172,7 +195,7 @@ impl Decompress {
     pub fn decompress<'a>(
         &mut self,
         input: &'a [u8],
-        output: &'a mut russh_cryptovec::CryptoVec,
+        output: &'a mut Vec<u8>,
     ) -> Result<&'a [u8], crate::Error> {
         match *self {
             Decompress::None => Ok(input),
@@ -180,7 +203,7 @@ impl Decompress {
                 output.clear();
                 let n_in = z.total_in() as usize;
                 let n_out = z.total_out() as usize;
-                output.resize(input.len());
+                output.resize(input.len(), 0);
                 let flush = flate2::FlushDecompress::None;
                 loop {
                     let n_in_ = z.total_in() as usize - n_in;
@@ -189,7 +212,7 @@ impl Decompress {
                     let d = z.decompress(&input[n_in_..], &mut output[n_out_..], flush);
                     match d? {
                         flate2::Status::Ok => {
-                            output.resize(output.len() * 2);
+                            output.resize(output.len() * 2, 0);
                         }
                         _ => break,
                     }
diff --git a/crates/bssh-russh/src/kex/curve25519.rs b/crates/bssh-russh/src/kex/curve25519.rs
index a6293f67..ed43e8ed 100644
--- a/crates/bssh-russh/src/kex/curve25519.rs
+++ b/crates/bssh-russh/src/kex/curve25519.rs
@@ -3,6 +3,7 @@ use curve25519_dalek::constants::ED25519_BASEPOINT_TABLE;
 use curve25519_dalek::montgomery::MontgomeryPoint;
 use curve25519_dalek::scalar::Scalar;
 use log::debug;
+use sha2::Digest;
 use ssh_encoding::{Encode, Writer};
 
 use super::{
@@ -78,7 +79,7 @@ impl KexAlgorithmImplementor for Curve25519Kex {
 
         // fill exchange.
         exchange.server_ephemeral.clear();
-        exchange.server_ephemeral.extend(&server_pubkey.0);
+        exchange.server_ephemeral.extend_from_slice(&server_pubkey.0);
         let shared = server_secret * client_pubkey;
         self.shared_secret = Some(shared);
         Ok(())
@@ -87,7 +88,7 @@ impl KexAlgorithmImplementor for Curve25519Kex {
     #[doc(hidden)]
     fn client_dh(
         &mut self,
-        client_ephemeral: &mut CryptoVec,
+        client_ephemeral: &mut Vec<u8>,
         writer: &mut impl Writer,
     ) -> Result<(), crate::Error> {
         let client_secret = Scalar::from_bytes_mod_order(rand::random::<[u8; 32]>());
@@ -95,7 +96,7 @@ impl KexAlgorithmImplementor for Curve25519Kex {
 
         // fill exchange.
         client_ephemeral.clear();
-        client_ephemeral.extend(&client_pubkey.0);
+        client_ephemeral.extend_from_slice(&client_pubkey.0);
 
         msg::KEX_ECDH_INIT.encode(writer)?;
         client_pubkey.0.encode(writer)?;
@@ -119,10 +120,10 @@ impl KexAlgorithmImplementor for Curve25519Kex {
 
     fn compute_exchange_hash(
         &self,
-        key: &CryptoVec,
+        key: &[u8],
         exchange: &Exchange,
         buffer: &mut CryptoVec,
-    ) -> Result<CryptoVec, crate::Error> {
+    ) -> Result<Vec<u8>, crate::Error> {
         // Computing the exchange hash, see page 7 of RFC 5656.
         buffer.clear();
         exchange.client_id.encode(buffer)?;
@@ -138,19 +139,16 @@ impl KexAlgorithmImplementor for Curve25519Kex {
             encode_mpint(&shared.0, buffer)?;
         }
 
-        use sha2::Digest;
         let mut hasher = sha2::Sha256::new();
         hasher.update(&buffer);
 
-        let mut res = CryptoVec::new();
-        res.extend(&hasher.finalize());
-        Ok(res)
+        Ok(hasher.finalize().to_vec())
     }
 
     fn compute_keys(
         &self,
-        session_id: &CryptoVec,
-        exchange_hash: &CryptoVec,
+        session_id: &[u8],
+        exchange_hash: &[u8],
         cipher: cipher::Name,
         remote_to_local_mac: mac::Name,
         local_to_remote_mac: mac::Name,
diff --git a/crates/bssh-russh/src/kex/dh/groups.rs b/crates/bssh-russh/src/kex/dh/groups.rs
index 58259c5f..8ee65baa 100644
--- a/crates/bssh-russh/src/kex/dh/groups.rs
+++ b/crates/bssh-russh/src/kex/dh/groups.rs
@@ -1,9 +1,9 @@
 use std::fmt::Debug;
 use std::ops::Deref;
 
+use crate::keys::ssh_key::rand_core::OsRng;
 use hex_literal::hex;
 use num_bigint::{BigUint, RandBigInt};
-use rand;
 
 #[derive(Clone)]
 pub enum DhGroupUInt {
@@ -282,7 +282,7 @@ impl DH {
 
     pub fn generate_private_key(&mut self, is_server: bool) -> BigUint {
         let q = (&self.prime_num - &BigUint::from(1u8)) / &BigUint::from(2u8);
-        let mut rng = rand::thread_rng();
+        let mut rng = OsRng;
         self.private_key =
             rng.gen_biguint_range(&if is_server { 1u8.into() } else { 2u8.into() }, &q);
         self.private_key.clone()
diff --git a/crates/bssh-russh/src/kex/dh/mod.rs b/crates/bssh-russh/src/kex/dh/mod.rs
index b54b0b90..701ceaac 100644
--- a/crates/bssh-russh/src/kex/dh/mod.rs
+++ b/crates/bssh-russh/src/kex/dh/mod.rs
@@ -195,7 +195,7 @@ impl<D: Digest> KexAlgorithmImplementor for DhGroupKex<D> {
 
         // fill exchange.
         exchange.server_ephemeral.clear();
-        exchange.server_ephemeral.extend(&encoded_server_pubkey);
+        exchange.server_ephemeral.extend_from_slice(&encoded_server_pubkey);
 
         let decoded_client_pubkey = DH::decode_public_key(client_pubkey);
         if !dh.validate_public_key(&decoded_client_pubkey) {
@@ -213,7 +213,7 @@ impl<D: Digest> KexAlgorithmImplementor for DhGroupKex<D> {
     #[doc(hidden)]
     fn client_dh(
         &mut self,
-        client_ephemeral: &mut CryptoVec,
+        client_ephemeral: &mut Vec<u8>,
         writer: &mut impl Writer,
     ) -> Result<(), Error> {
         let Some(dh) = self.dh.as_mut() else {
@@ -231,7 +231,7 @@ impl<D: Digest> KexAlgorithmImplementor for DhGroupKex<D> {
         // fill exchange.
         let encoded_pubkey = biguint_to_mpint(client_pubkey);
         client_ephemeral.clear();
-        client_ephemeral.extend(&encoded_pubkey);
+        client_ephemeral.extend_from_slice(&encoded_pubkey);
 
         if self.is_dh_gex {
             msg::KEX_DH_GEX_INIT.encode(writer)?;
@@ -270,10 +270,10 @@ impl<D: Digest> KexAlgorithmImplementor for DhGroupKex<D> {
 
     fn compute_exchange_hash(
         &self,
-        key: &CryptoVec,
+        key: &[u8],
         exchange: &Exchange,
         buffer: &mut CryptoVec,
-    ) -> Result<CryptoVec, Error> {
+    ) -> Result<Vec<u8>, Error> {
         // Computing the exchange hash, see page 7 of RFC 5656.
         buffer.clear();
         exchange.client_id.encode(buffer)?;
@@ -299,15 +299,13 @@ impl<D: Digest> KexAlgorithmImplementor for DhGroupKex<D> {
         let mut hasher = D::new();
         hasher.update(&buffer);
 
-        let mut res = CryptoVec::new();
-        res.extend(&hasher.finalize());
-        Ok(res)
+        Ok(hasher.finalize().to_vec())
     }
 
     fn compute_keys(
         &self,
-        session_id: &CryptoVec,
-        exchange_hash: &CryptoVec,
+        session_id: &[u8],
+        exchange_hash: &[u8],
         cipher: cipher::Name,
         remote_to_local_mac: mac::Name,
         local_to_remote_mac: mac::Name,
diff --git a/crates/bssh-russh/src/kex/ecdh_nistp.rs b/crates/bssh-russh/src/kex/ecdh_nistp.rs
index bff8f1ad..a7a8b76e 100644
--- a/crates/bssh-russh/src/kex/ecdh_nistp.rs
+++ b/crates/bssh-russh/src/kex/ecdh_nistp.rs
@@ -1,6 +1,7 @@
 use std::marker::PhantomData;
 use std::ops::Deref;
 
+use crate::keys::ssh_key::rand_core::OsRng;
 use byteorder::{BigEndian, ByteOrder};
 use elliptic_curve::ecdh::{EphemeralSecret, SharedSecret};
 use elliptic_curve::point::PointCompression;
@@ -105,15 +106,14 @@ where
                 .map_err(|_| crate::Error::Inconsistent)?
         };
 
-        let server_secret =
-            elliptic_curve::ecdh::EphemeralSecret::<C>::random(&mut rand_core::OsRng);
+        let server_secret = elliptic_curve::ecdh::EphemeralSecret::<C>::random(&mut OsRng);
         let server_pubkey = server_secret.public_key();
 
         // fill exchange.
         exchange.server_ephemeral.clear();
         exchange
             .server_ephemeral
-            .extend(&server_pubkey.to_sec1_bytes());
+            .extend_from_slice(&server_pubkey.to_sec1_bytes());
         let shared = server_secret.diffie_hellman(&client_pubkey);
         self.shared_secret = Some(shared);
         Ok(())
@@ -122,16 +122,15 @@ where
     #[doc(hidden)]
     fn client_dh(
         &mut self,
-        client_ephemeral: &mut CryptoVec,
+        client_ephemeral: &mut Vec<u8>,
         writer: &mut impl Writer,
     ) -> Result<(), crate::Error> {
-        let client_secret =
-            elliptic_curve::ecdh::EphemeralSecret::<C>::random(&mut rand_core::OsRng);
+        let client_secret = elliptic_curve::ecdh::EphemeralSecret::<C>::random(&mut OsRng);
         let client_pubkey = client_secret.public_key();
 
         // fill exchange.
         client_ephemeral.clear();
-        client_ephemeral.extend(&client_pubkey.to_sec1_bytes());
+        client_ephemeral.extend_from_slice(&client_pubkey.to_sec1_bytes());
 
         msg::KEX_ECDH_INIT.encode(writer)?;
         client_pubkey.to_sec1_bytes().encode(writer)?;
@@ -156,10 +155,10 @@ where
 
     fn compute_exchange_hash(
         &self,
-        key: &CryptoVec,
+        key: &[u8],
         exchange: &Exchange,
         buffer: &mut CryptoVec,
-    ) -> Result<CryptoVec, crate::Error> {
+    ) -> Result<Vec<u8>, crate::Error> {
         // Computing the exchange hash, see page 7 of RFC 5656.
         buffer.clear();
         exchange.client_id.deref().encode(buffer)?;
@@ -178,15 +177,13 @@ where
         let mut hasher = D::new();
         hasher.update(&buffer);
 
-        let mut res = CryptoVec::new();
-        res.extend(&hasher.finalize());
-        Ok(res)
+        Ok(hasher.finalize().to_vec())
     }
 
     fn compute_keys(
         &self,
-        session_id: &CryptoVec,
-        exchange_hash: &CryptoVec,
+        session_id: &[u8],
+        exchange_hash: &[u8],
         cipher: cipher::Name,
         remote_to_local_mac: mac::Name,
         local_to_remote_mac: mac::Name,
@@ -217,14 +214,14 @@ mod tests {
     #[test]
     fn test_shared_secret() {
         let mut party1 = EcdhNistPKex::<NistP256, Sha256> {
-            local_secret: Some(EphemeralSecret::<NistP256>::random(&mut rand_core::OsRng)),
+            local_secret: Some(EphemeralSecret::<NistP256>::random(&mut OsRng)),
             shared_secret: None,
             _digest: PhantomData,
         };
         let p1_pubkey = party1.local_secret.as_ref().unwrap().public_key();
 
         let mut party2 = EcdhNistPKex::<NistP256, Sha256> {
-            local_secret: Some(EphemeralSecret::<NistP256>::random(&mut rand_core::OsRng)),
+            local_secret: Some(EphemeralSecret::<NistP256>::random(&mut OsRng)),
             shared_secret: None,
             _digest: PhantomData,
         };
diff --git a/crates/bssh-russh/src/kex/hybrid_mlkem.rs b/crates/bssh-russh/src/kex/hybrid_mlkem.rs
index 9e901061..8a94e8d1 100644
--- a/crates/bssh-russh/src/kex/hybrid_mlkem.rs
+++ b/crates/bssh-russh/src/kex/hybrid_mlkem.rs
@@ -2,24 +2,28 @@ use byteorder::{BigEndian, ByteOrder};
 use curve25519_dalek::constants::ED25519_BASEPOINT_TABLE;
 use curve25519_dalek::montgomery::MontgomeryPoint;
 use curve25519_dalek::scalar::Scalar;
-use libcrux_ml_kem::mlkem768::{
-    decapsulate, encapsulate, generate_key_pair, MlKem768Ciphertext, MlKem768PrivateKey,
-    MlKem768PublicKey,
-};
-use libcrux_ml_kem::{KEY_GENERATION_SEED_SIZE, SHARED_SECRET_SIZE};
 use log::debug;
+use ml_kem::{
+    EncodedSizeUser, KemCore, MlKem768, MlKem768Params,
+    kem::{Decapsulate, DecapsulationKey, Encapsulate, EncapsulationKey},
+};
 use sha2::Digest;
 use ssh_encoding::{Encode, Writer};
 
-use super::{compute_keys, KexAlgorithm, KexAlgorithmImplementor, KexType, SharedSecret};
+use super::{KexAlgorithm, KexAlgorithmImplementor, KexType, SharedSecret, compute_keys};
+use crate::keys::ssh_key::rand_core::OsRng;
 use crate::mac;
 use crate::session::Exchange;
-use crate::{cipher, msg, CryptoVec, Error};
+use crate::{CryptoVec, Error, cipher, msg};
 
 const MLKEM768_PUBLIC_KEY_SIZE: usize = 1184;
 const MLKEM768_CIPHERTEXT_SIZE: usize = 1088;
 const X25519_PUBLIC_KEY_SIZE: usize = 32;
 
+type MlKem768PublicKey = EncapsulationKey<MlKem768Params>;
+type MlKem768PrivateKey = DecapsulationKey<MlKem768Params>;
+type MlKem768Ciphertext = ml_kem::Ciphertext<MlKem768>;
+
 pub struct MlKem768X25519KexType {}
 
 impl KexType for MlKem768X25519KexType {
@@ -38,7 +42,7 @@ impl KexType for MlKem768X25519KexType {
 pub struct MlKem768X25519Kex {
     mlkem_secret: Option<Box<MlKem768PrivateKey>>,
     x25519_secret: Option<Scalar>,
-    k_pq: Option<[u8; SHARED_SECRET_SIZE]>,
+    k_pq: Option<ml_kem::SharedKey<MlKem768>>,
     k_cl: Option<MontgomeryPoint>,
 }
 
@@ -82,17 +86,15 @@ impl KexAlgorithmImplementor for MlKem768X25519Kex {
         #[allow(clippy::indexing_slicing)]
         let c_pk1_bytes = &c_init[MLKEM768_PUBLIC_KEY_SIZE..];
 
-        let mut c_pk2_array = [0u8; MLKEM768_PUBLIC_KEY_SIZE];
-        c_pk2_array.copy_from_slice(c_pk2_bytes);
-        let c_pk2 = MlKem768PublicKey::from(c_pk2_array);
+        let c_pk2_array =
+            ml_kem::Encoded::<MlKem768PublicKey>::try_from(c_pk2_bytes).map_err(|_| Error::Kex)?;
+        let c_pk2 = MlKem768PublicKey::from_bytes(&c_pk2_array);
 
         let mut c_pk1 = MontgomeryPoint([0; 32]);
         c_pk1.0.copy_from_slice(c_pk1_bytes);
 
-        let mut randomness = [0u8; SHARED_SECRET_SIZE];
-        getrandom::getrandom(&mut randomness).map_err(|_| Error::KexInit)?;
-
-        let (s_ct2, k_pq_shared_secret) = encapsulate(&c_pk2, randomness);
+        let (s_ct2, k_pq_shared_secret) =
+            c_pk2.encapsulate(&mut OsRng).map_err(|_| Error::KexInit)?;
 
         let s_secret = Scalar::from_bytes_mod_order(rand::random::<[u8; 32]>());
         let s_pk1 = (ED25519_BASEPOINT_TABLE * &s_secret).to_montgomery();
@@ -100,8 +102,10 @@ impl KexAlgorithmImplementor for MlKem768X25519Kex {
         let k_cl = s_secret * c_pk1;
 
         exchange.server_ephemeral.clear();
-        exchange.server_ephemeral.extend(s_ct2.as_slice());
-        exchange.server_ephemeral.extend(&s_pk1.0);
+        exchange
+            .server_ephemeral
+            .extend_from_slice(s_ct2.as_slice());
+        exchange.server_ephemeral.extend_from_slice(&s_pk1.0);
 
         self.k_pq = Some(k_pq_shared_secret);
         self.k_cl = Some(k_cl);
@@ -111,25 +115,21 @@ impl KexAlgorithmImplementor for MlKem768X25519Kex {
 
     fn client_dh(
         &mut self,
-        client_ephemeral: &mut CryptoVec,
+        client_ephemeral: &mut Vec<u8>,
         writer: &mut impl Writer,
     ) -> Result<(), Error> {
-        let mut randomness = [0u8; KEY_GENERATION_SEED_SIZE];
-        getrandom::getrandom(&mut randomness).map_err(|_| Error::KexInit)?;
-
-        let keypair = generate_key_pair(randomness);
-        let (mlkem_sk, mlkem_pk) = keypair.into_parts();
+        let (mlkem_sk, mlkem_pk) = MlKem768::generate(&mut OsRng);
 
         let x25519_secret = Scalar::from_bytes_mod_order(rand::random::<[u8; 32]>());
         let x25519_pk = (ED25519_BASEPOINT_TABLE * &x25519_secret).to_montgomery();
 
         client_ephemeral.clear();
-        client_ephemeral.extend(mlkem_pk.as_slice());
+        client_ephemeral.extend(&mlkem_pk.as_bytes());
         client_ephemeral.extend(&x25519_pk.0);
 
         msg::KEX_HYBRID_INIT.encode(writer)?;
         let mut c_init = Vec::<u8>::new();
-        c_init.extend(mlkem_pk.as_slice());
+        c_init.extend(mlkem_pk.as_bytes());
         c_init.extend(&x25519_pk.0);
         c_init.as_slice().encode(writer)?;
 
@@ -149,12 +149,12 @@ impl KexAlgorithmImplementor for MlKem768X25519Kex {
         #[allow(clippy::indexing_slicing)]
         let s_pk1_bytes = &remote_pubkey_[MLKEM768_CIPHERTEXT_SIZE..];
 
-        let mut s_ct2_array = [0u8; MLKEM768_CIPHERTEXT_SIZE];
-        s_ct2_array.copy_from_slice(s_ct2_bytes);
-        let s_ct2 = MlKem768Ciphertext::from(s_ct2_array);
+        let s_ct2 = MlKem768Ciphertext::try_from(s_ct2_bytes).map_err(|_| Error::KexInit)?;
 
         let mlkem_secret = self.mlkem_secret.take().ok_or(Error::KexInit)?;
-        let k_pq_shared_secret = decapsulate(&mlkem_secret, &s_ct2);
+        let k_pq_shared_secret = mlkem_secret
+            .decapsulate(&s_ct2)
+            .map_err(|_| Error::KexInit)?;
 
         let mut s_pk1 = MontgomeryPoint([0; 32]);
         s_pk1.0.copy_from_slice(s_pk1_bytes);
@@ -178,10 +178,10 @@ impl KexAlgorithmImplementor for MlKem768X25519Kex {
 
     fn compute_exchange_hash(
         &self,
-        key: &CryptoVec,
+        key: &[u8],
         exchange: &Exchange,
         buffer: &mut CryptoVec,
-    ) -> Result<CryptoVec, Error> {
+    ) -> Result<Vec<u8>, Error> {
         buffer.clear();
         exchange.client_id.encode(buffer)?;
         exchange.server_id.encode(buffer)?;
@@ -209,15 +209,13 @@ impl KexAlgorithmImplementor for MlKem768X25519Kex {
         let mut hasher = sha2::Sha256::new();
         hasher.update(&buffer);
 
-        let mut res = CryptoVec::new();
-        res.extend(&hasher.finalize());
-        Ok(res)
+        Ok(hasher.finalize().to_vec())
     }
 
     fn compute_keys(
         &self,
-        session_id: &CryptoVec,
-        exchange_hash: &CryptoVec,
+        session_id: &[u8],
+        exchange_hash: &[u8],
         cipher: cipher::Name,
         remote_to_local_mac: mac::Name,
         local_to_remote_mac: mac::Name,
@@ -269,8 +267,8 @@ mod tests {
             k_cl: None,
         };
 
-        let mut client_ephemeral = CryptoVec::new();
-        let mut client_init_msg = CryptoVec::new();
+        let mut client_ephemeral = Vec::new();
+        let mut client_init_msg = Vec::new();
 
         client_kex
             .client_dh(&mut client_ephemeral, &mut client_init_msg)
@@ -333,19 +331,19 @@ mod tests {
             k_cl: None,
         };
 
-        let mut client_ephemeral = CryptoVec::new();
-        let mut client_init_msg = CryptoVec::new();
+        let mut client_ephemeral = Vec::new();
+        let mut client_init_msg = Vec::new();
         client_kex
             .client_dh(&mut client_ephemeral, &mut client_init_msg)
             .unwrap();
 
         let mut exchange = Exchange {
-            client_id: b"SSH-2.0-Test_Client".as_ref().into(),
-            server_id: b"SSH-2.0-Test_Server".as_ref().into(),
-            client_kex_init: CryptoVec::from_slice(b"client_kex_init"),
-            server_kex_init: CryptoVec::from_slice(b"server_kex_init"),
+            client_id: b"SSH-2.0-Test_Client".to_vec(),
+            server_id: b"SSH-2.0-Test_Server".to_vec(),
+            client_kex_init: b"client_kex_init".to_vec(),
+            server_kex_init: b"server_kex_init".to_vec(),
             client_ephemeral: client_ephemeral.clone(),
-            server_ephemeral: CryptoVec::new(),
+            server_ephemeral: Vec::new(),
             gex: None,
         };
 
@@ -356,20 +354,19 @@ mod tests {
             .compute_shared_secret(&exchange.server_ephemeral)
             .unwrap();
 
-        let key = CryptoVec::from_slice(b"test_host_key");
+        let key = b"test_host_key";
         let mut buffer = CryptoVec::new();
 
         let client_hash = client_kex
-            .compute_exchange_hash(&key, &exchange, &mut buffer)
+            .compute_exchange_hash(key, &exchange, &mut buffer)
             .unwrap();
 
         let server_hash = server_kex
-            .compute_exchange_hash(&key, &exchange, &mut buffer)
+            .compute_exchange_hash(key, &exchange, &mut buffer)
             .unwrap();
 
         assert_eq!(
-            client_hash.as_ref(),
-            server_hash.as_ref(),
+            client_hash, server_hash,
             "Exchange hashes should match between client and server"
         );
         assert_eq!(client_hash.len(), 32, "SHA-256 hash should be 32 bytes");
@@ -384,8 +381,8 @@ mod tests {
             k_cl: None,
         };
 
-        let mut client_ephemeral = CryptoVec::new();
-        let mut client_init_msg = CryptoVec::new();
+        let mut client_ephemeral = Vec::new();
+        let mut client_init_msg = Vec::new();
         client_kex
             .client_dh(&mut client_ephemeral, &mut client_init_msg)
             .unwrap();
@@ -425,8 +422,8 @@ mod tests {
             k_cl: None,
         };
 
-        let mut client_ephemeral = CryptoVec::new();
-        let mut client_init_msg = CryptoVec::new();
+        let mut client_ephemeral = Vec::new();
+        let mut client_init_msg = Vec::new();
         client_kex
             .client_dh(&mut client_ephemeral, &mut client_init_msg)
             .unwrap();
diff --git a/crates/bssh-russh/src/kex/mod.rs b/crates/bssh-russh/src/kex/mod.rs
index d322dc73..2da167b0 100644
--- a/crates/bssh-russh/src/kex/mod.rs
+++ b/crates/bssh-russh/src/kex/mod.rs
@@ -174,7 +174,7 @@ pub(crate) trait KexAlgorithmImplementor {
 
     fn client_dh(
         &mut self,
-        client_ephemeral: &mut CryptoVec,
+        client_ephemeral: &mut Vec<u8>,
         writer: &mut impl Writer,
     ) -> Result<(), Error>;
 
@@ -190,15 +190,15 @@ pub(crate) trait KexAlgorithmImplementor {
 
     fn compute_exchange_hash(
         &self,
-        key: &CryptoVec,
+        key: &[u8],
         exchange: &Exchange,
         buffer: &mut CryptoVec,
-    ) -> Result<CryptoVec, Error>;
+    ) -> Result<Vec<u8>, Error>;
 
     fn compute_keys(
         &self,
-        session_id: &CryptoVec,
-        exchange_hash: &CryptoVec,
+        session_id: &[u8],
+        exchange_hash: &[u8],
         cipher: cipher::Name,
         remote_to_local_mac: mac::Name,
         local_to_remote_mac: mac::Name,
@@ -361,8 +361,8 @@ impl SharedSecret {
 
 pub(crate) fn compute_keys<D: Digest>(
     shared_secret: Option<&SharedSecret>,
-    session_id: &CryptoVec,
-    exchange_hash: &CryptoVec,
+    session_id: &[u8],
+    exchange_hash: &[u8],
     cipher: cipher::Name,
     remote_to_local_mac: mac::Name,
     local_to_remote_mac: mac::Name,
diff --git a/crates/bssh-russh/src/kex/none.rs b/crates/bssh-russh/src/kex/none.rs
index 3707e646..fcf967a6 100644
--- a/crates/bssh-russh/src/kex/none.rs
+++ b/crates/bssh-russh/src/kex/none.rs
@@ -1,7 +1,6 @@
 use ssh_encoding::Writer;
 
 use super::{KexAlgorithm, KexAlgorithmImplementor, KexType};
-use crate::CryptoVec;
 
 pub struct NoneKexType {}
 
@@ -29,7 +28,7 @@ impl KexAlgorithmImplementor for NoneKexAlgorithm {
 
     fn client_dh(
         &mut self,
-        _client_ephemeral: &mut russh_cryptovec::CryptoVec,
+        _client_ephemeral: &mut Vec<u8>,
         _buf: &mut impl Writer,
     ) -> Result<(), crate::Error> {
         Ok(())
@@ -45,17 +44,17 @@ impl KexAlgorithmImplementor for NoneKexAlgorithm {
 
     fn compute_exchange_hash(
         &self,
-        _key: &russh_cryptovec::CryptoVec,
+        _key: &[u8],
         _exchange: &crate::session::Exchange,
         _buffer: &mut russh_cryptovec::CryptoVec,
-    ) -> Result<russh_cryptovec::CryptoVec, crate::Error> {
-        Ok(CryptoVec::new())
+    ) -> Result<Vec<u8>, crate::Error> {
+        Ok(Vec::new())
     }
 
     fn compute_keys(
         &self,
-        session_id: &russh_cryptovec::CryptoVec,
-        exchange_hash: &russh_cryptovec::CryptoVec,
+        session_id: &[u8],
+        exchange_hash: &[u8],
         cipher: crate::cipher::Name,
         remote_to_local_mac: crate::mac::Name,
         local_to_remote_mac: crate::mac::Name,
diff --git a/crates/bssh-russh/src/keys/agent/client.rs b/crates/bssh-russh/src/keys/agent/client.rs
index d43e1323..53c39cf2 100644
--- a/crates/bssh-russh/src/keys/agent/client.rs
+++ b/crates/bssh-russh/src/keys/agent/client.rs
@@ -4,14 +4,14 @@ use byteorder::{BigEndian, ByteOrder};
 use bytes::Bytes;
 use log::{debug, error};
 use ssh_encoding::{Decode, Encode, Reader};
-use ssh_key::{Algorithm, HashAlg, PrivateKey, PublicKey, Signature};
+use ssh_key::{Algorithm, Certificate, HashAlg, PrivateKey, PublicKey, Signature};
 use tokio;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 
-use super::{msg, Constraint};
-use crate::helpers::EncodedExt;
-use crate::keys::{key, Error};
+use super::{AgentIdentity, Constraint, msg};
 use crate::CryptoVec;
+use crate::helpers::EncodedExt;
+use crate::keys::{Error, key};
 
 pub trait AgentStream: AsyncRead + AsyncWrite {}
 
@@ -20,7 +20,7 @@ impl<S: AsyncRead + AsyncWrite> AgentStream for S {}
 /// SSH agent client.
 pub struct AgentClient<S: AgentStream> {
     stream: S,
-    buf: CryptoVec,
+    buf: Vec<u8>,
 }
 
 impl<S: AgentStream + Send + Unpin + 'static> AgentClient<S> {
@@ -45,7 +45,7 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
     pub fn connect(stream: S) -> Self {
         AgentClient {
             stream,
-            buf: CryptoVec::new(),
+            buf: Vec::new(),
         }
     }
 }
@@ -58,7 +58,7 @@ impl AgentClient<tokio::net::UnixStream> {
         let stream = tokio::net::UnixStream::connect(path).await?;
         Ok(AgentClient {
             stream,
-            buf: CryptoVec::new(),
+            buf: Vec::new(),
         })
     }
 
@@ -106,7 +106,7 @@ impl AgentClient<tokio::net::windows::named_pipe::NamedPipeClient> {
 
         Ok(AgentClient {
             stream,
-            buf: CryptoVec::new(),
+            buf: Vec::new(),
         })
     }
 }
@@ -119,13 +119,13 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
 
         // Reading the length
         self.buf.clear();
-        self.buf.resize(4);
+        self.buf.resize(4, 0);
         self.stream.read_exact(&mut self.buf).await?;
 
         // Reading the rest of the buffer
         let len = BigEndian::read_u32(&self.buf) as usize;
         self.buf.clear();
-        self.buf.resize(len);
+        self.buf.resize(len, 0);
         self.stream.read_exact(&mut self.buf).await?;
 
         Ok(())
@@ -150,7 +150,7 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
         // See IETF draft-miller-ssh-agent-13, section 3.2 for format.
         // https://datatracker.ietf.org/doc/html/draft-miller-ssh-agent
         self.buf.clear();
-        self.buf.resize(4);
+        self.buf.resize(4, 0);
         if constraints.is_empty() {
             self.buf.push(msg::ADD_IDENTITY)
         } else {
@@ -195,7 +195,7 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
         constraints: &[Constraint],
     ) -> Result<(), Error> {
         self.buf.clear();
-        self.buf.resize(4);
+        self.buf.resize(4, 0);
         if constraints.is_empty() {
             self.buf.push(msg::ADD_SMARTCARD_KEY)
         } else {
@@ -232,7 +232,7 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
     /// Lock the agent, making it refuse to sign until unlocked.
     pub async fn lock(&mut self, passphrase: &[u8]) -> Result<(), Error> {
         self.buf.clear();
-        self.buf.resize(4);
+        self.buf.resize(4, 0);
         self.buf.push(msg::LOCK);
         passphrase.encode(&mut self.buf)?;
         let len = self.buf.len() - 4;
@@ -244,7 +244,7 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
     /// Unlock the agent, allowing it to sign again.
     pub async fn unlock(&mut self, passphrase: &[u8]) -> Result<(), Error> {
         self.buf.clear();
-        self.buf.resize(4);
+        self.buf.resize(4, 0);
         msg::UNLOCK.encode(&mut self.buf)?;
         passphrase.encode(&mut self.buf)?;
         let len = self.buf.len() - 4;
@@ -254,18 +254,17 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
         Ok(())
     }
 
-    /// Ask the agent for a list of the currently registered secret
-    /// keys.
-    pub async fn request_identities(&mut self) -> Result<Vec<PublicKey>, Error> {
+    /// Ask the agent for a list of identities, including certificates.
+    pub async fn request_identities(&mut self) -> Result<Vec<AgentIdentity>, Error> {
         self.buf.clear();
-        self.buf.resize(4);
+        self.buf.resize(4, 0);
         msg::REQUEST_IDENTITIES.encode(&mut self.buf)?;
         let len = self.buf.len() - 4;
         BigEndian::write_u32(&mut self.buf[..], len as u32);
 
         self.read_response().await?;
         debug!("identities: {:?}", &self.buf[..]);
-        let mut keys = Vec::new();
+        let mut identities = Vec::new();
 
         #[allow(clippy::indexing_slicing)] // static length
         if let Some((&msg::IDENTITIES_ANSWER, mut r)) = self.buf.split_first() {
@@ -273,22 +272,70 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
             for _ in 0..n {
                 let key_blob = Bytes::decode(&mut r)?;
                 let comment = String::decode(&mut r)?;
-                let mut key = key::parse_public_key(&key_blob)?;
-                key.set_comment(comment);
-                keys.push(key);
+
+                // Check if blob starts with a certificate algorithm by reading the algorithm string.
+                // Certificate algorithms end with "-cert-v01@openssh.com".
+                // This avoids parsing the blob twice for regular keys.
+                let identity = if Self::is_certificate_blob(&key_blob) {
+                    match Certificate::decode(&mut key_blob.as_ref()) {
+                        Ok(cert) => AgentIdentity::Certificate { certificate: cert, comment },
+                        Err(_) => {
+                            // Fallback to public key if certificate parsing fails
+                            let key = key::parse_public_key(&key_blob)?;
+                            AgentIdentity::PublicKey { key, comment }
+                        }
+                    }
+                } else {
+                    let key = key::parse_public_key(&key_blob)?;
+                    AgentIdentity::PublicKey { key, comment }
+                };
+                identities.push(identity);
             }
         }
 
-        Ok(keys)
+        Ok(identities)
+    }
+
+    /// Check if a key blob appears to be a certificate by examining the algorithm prefix.
+    /// Certificate algorithms end with "-cert-v01@openssh.com".
+    fn is_certificate_blob(blob: &[u8]) -> bool {
+        // The blob starts with a length-prefixed string containing the algorithm name.
+        // Read the length (4 bytes, big-endian) and then the algorithm string.
+        let Some(len_bytes) = blob.get(..4) else {
+            return false;
+        };
+        let alg_len = BigEndian::read_u32(len_bytes) as usize;
+        let Some(alg_bytes) = blob.get(4..4 + alg_len) else {
+            return false;
+        };
+        if let Ok(alg_str) = str::from_utf8(alg_bytes) {
+            alg_str.ends_with("-cert-v01@openssh.com")
+        } else {
+            false
+        }
     }
 
     /// Ask the agent to sign the supplied piece of data.
     pub async fn sign_request(
+        &mut self,
+        identity: &AgentIdentity,
+        hash_alg: Option<HashAlg>,
+        data: Vec<u8>,
+    ) -> Result<Vec<u8>, Error> {
+        match identity {
+            AgentIdentity::PublicKey { key, .. } => self.sign_request_pk(key, hash_alg, data).await,
+            AgentIdentity::Certificate { certificate, .. } => {
+                self.sign_request_cert(certificate, hash_alg, data).await
+            }
+        }
+    }
+
+    async fn sign_request_pk(
         &mut self,
         public: &PublicKey,
         hash_alg: Option<HashAlg>,
-        mut data: CryptoVec,
-    ) -> Result<CryptoVec, Error> {
+        mut data: Vec<u8>,
+    ) -> Result<Vec<u8>, Error> {
         debug!("sign_request: {data:?}");
         let hash = self.prepare_sign_request(public, hash_alg, &data)?;
 
@@ -307,6 +354,56 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
         }
     }
 
+    /// Ask the agent to sign data using a certificate identity.
+    ///
+    /// This sends the certificate blob to the agent (not just the public key),
+    /// allowing the agent to match it to the correct private key.
+    ///
+    /// For RSA certificates, you can specify the hash algorithm to use.
+    async fn sign_request_cert(
+        &mut self,
+        cert: &Certificate,
+        hash_alg: Option<HashAlg>,
+        mut data: Vec<u8>,
+    ) -> Result<Vec<u8>, Error> {
+        debug!("sign_request_cert: {data:?}");
+
+        self.buf.clear();
+        self.buf.resize(4, 0);
+        msg::SIGN_REQUEST.encode(&mut self.buf)?;
+        cert.to_bytes()?.encode(&mut self.buf)?;
+        data.encode(&mut self.buf)?;
+
+        // Calculate hash flag for RSA certificates (same logic as prepare_sign_request)
+        let hash = match cert.algorithm() {
+            Algorithm::Rsa { .. } => match hash_alg {
+                Some(HashAlg::Sha256) => 2,
+                Some(HashAlg::Sha512) => 4,
+                _ => 0,
+            },
+            _ => 0,
+        };
+
+        hash.encode(&mut self.buf)?;
+
+        let len = self.buf.len() - 4;
+        BigEndian::write_u32(&mut self.buf[..], len as u32);
+
+        self.read_response().await?;
+
+        match self.buf.split_first() {
+            Some((&msg::SIGN_RESPONSE, mut r)) => {
+                self.write_signature(&mut r, hash, &mut data)?;
+                Ok(data)
+            }
+            Some((&msg::FAILURE, _)) => Err(Error::AgentFailure),
+            _ => {
+                debug!("self.buf = {:?}", &self.buf[..]);
+                Err(Error::AgentProtocolError)
+            }
+        }
+    }
+
     fn prepare_sign_request(
         &mut self,
         public: &ssh_key::PublicKey,
@@ -314,7 +411,7 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
         data: &[u8],
     ) -> Result<u32, Error> {
         self.buf.clear();
-        self.buf.resize(4);
+        self.buf.resize(4, 0);
         msg::SIGN_REQUEST.encode(&mut self.buf)?;
         public.key_data().encoded()?.encode(&mut self.buf)?;
         data.encode(&mut self.buf)?;
@@ -339,7 +436,7 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
         &self,
         r: &mut R,
         hash: u32,
-        data: &mut CryptoVec,
+        data: &mut Vec<u8>,
     ) -> Result<(), Error> {
         let mut resp = &Bytes::decode(r)?[..];
         let t = String::decode(&mut resp)?;
@@ -409,7 +506,7 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
     /// Ask the agent to remove a key from its memory.
     pub async fn remove_identity(&mut self, public: &ssh_key::PublicKey) -> Result<(), Error> {
         self.buf.clear();
-        self.buf.resize(4);
+        self.buf.resize(4, 0);
         self.buf.push(msg::REMOVE_IDENTITY);
         public.key_data().encoded()?.encode(&mut self.buf)?;
         let len = self.buf.len() - 4;
@@ -421,7 +518,7 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
     /// Ask the agent to remove a smartcard from its memory.
     pub async fn remove_smartcard_key(&mut self, id: &str, pin: &[u8]) -> Result<(), Error> {
         self.buf.clear();
-        self.buf.resize(4);
+        self.buf.resize(4, 0);
         msg::REMOVE_SMARTCARD_KEY.encode(&mut self.buf)?;
         id.encode(&mut self.buf)?;
         pin.encode(&mut self.buf)?;
@@ -434,7 +531,7 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
     /// Ask the agent to forget all known keys.
     pub async fn remove_all_identities(&mut self) -> Result<(), Error> {
         self.buf.clear();
-        self.buf.resize(4);
+        self.buf.resize(4, 0);
         msg::REMOVE_ALL_IDENTITIES.encode(&mut self.buf)?;
         1u32.encode(&mut self.buf)?;
         self.read_success().await?;
@@ -444,7 +541,7 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
     /// Send a custom message to the agent.
     pub async fn extension(&mut self, typ: &[u8], ext: &[u8]) -> Result<(), Error> {
         self.buf.clear();
-        self.buf.resize(4);
+        self.buf.resize(4, 0);
         msg::EXTENSION.encode(&mut self.buf)?;
         typ.encode(&mut self.buf)?;
         ext.encode(&mut self.buf)?;
@@ -457,7 +554,7 @@ impl<S: AgentStream + Unpin> AgentClient<S> {
     /// Ask the agent what extensions about supported extensions.
     pub async fn query_extension(&mut self, typ: &[u8], mut ext: CryptoVec) -> Result<bool, Error> {
         self.buf.clear();
-        self.buf.resize(4);
+        self.buf.resize(4, 0);
         msg::EXTENSION.encode(&mut self.buf)?;
         typ.encode(&mut self.buf)?;
         let len = self.buf.len() - 4;
diff --git a/crates/bssh-russh/src/keys/agent/mod.rs b/crates/bssh-russh/src/keys/agent/mod.rs
index d7ec3f6d..af3beaec 100644
--- a/crates/bssh-russh/src/keys/agent/mod.rs
+++ b/crates/bssh-russh/src/keys/agent/mod.rs
@@ -1,3 +1,7 @@
+use std::borrow::Cow;
+
+use ssh_key::{Certificate, PublicKey};
+
 /// Write clients for SSH agents.
 pub mod client;
 mod msg;
@@ -14,3 +18,177 @@ pub enum Constraint {
     /// Custom constraints
     Extensions { name: Vec<u8>, details: Vec<u8> },
 }
+
+/// An identity held by an SSH agent, which may be either a plain public key
+/// or an OpenSSH certificate.
+#[derive(Debug, Clone)]
+#[allow(clippy::large_enum_variant)]
+pub enum AgentIdentity {
+    /// A plain public key
+    PublicKey {
+        /// The public key
+        key: PublicKey,
+        /// Comment associated with this identity
+        comment: String,
+    },
+    /// An OpenSSH certificate
+    Certificate {
+        /// The certificate (contains public key plus CA signature, principals, validity, etc.)
+        certificate: Certificate,
+        /// Comment associated with this identity
+        comment: String,
+    },
+}
+
+impl From<PublicKey> for AgentIdentity {
+    fn from(key: PublicKey) -> Self {
+        Self::PublicKey {
+            key,
+            comment: String::new(),
+        }
+    }
+}
+
+impl From<Certificate> for AgentIdentity {
+    fn from(certificate: Certificate) -> Self {
+        Self::Certificate {
+            certificate,
+            comment: String::new(),
+        }
+    }
+}
+
+impl AgentIdentity {
+    /// Returns the underlying public key.
+    /// For certificates, extracts the public key from the certificate.
+    /// Returns a borrowed reference for plain keys, or an owned value for certificates.
+    pub fn public_key(&self) -> Cow<'_, PublicKey> {
+        match self {
+            Self::PublicKey { key, .. } => Cow::Borrowed(key),
+            Self::Certificate { certificate, .. } => {
+                Cow::Owned(PublicKey::new(certificate.public_key().clone(), ""))
+            }
+        }
+    }
+
+    /// Returns the comment associated with this identity.
+    pub fn comment(&self) -> &str {
+        match self {
+            Self::PublicKey { comment, .. } => comment,
+            Self::Certificate { comment, .. } => comment,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ssh_key::rand_core::OsRng;
+    use ssh_key::{PrivateKey, certificate};
+
+    fn create_test_certificate() -> Certificate {
+        use std::time::{SystemTime, UNIX_EPOCH};
+
+        // Create a CA key
+        let ca_key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap();
+
+        // Create a user key to be certified
+        let user_key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap();
+
+        // Build and sign the certificate with reasonable validity window
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        let valid_after = now - 3600; // 1 hour ago
+        let valid_before = now + 86400 * 365; // 1 year from now
+
+        let mut builder = certificate::Builder::new_with_random_nonce(
+            &mut OsRng,
+            user_key.public_key(),
+            valid_after,
+            valid_before,
+        )
+        .unwrap();
+
+        builder.serial(1).unwrap();
+        builder.key_id("test-cert").unwrap();
+        builder.cert_type(certificate::CertType::User).unwrap();
+        builder.valid_principal("testuser").unwrap();
+        builder.sign(&ca_key).unwrap()
+    }
+
+    #[test]
+    fn test_agent_identity_public_key_variant() {
+        let key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519)
+            .unwrap()
+            .public_key()
+            .clone();
+        let comment = "test-key-comment".to_string();
+
+        let identity = AgentIdentity::PublicKey {
+            key: key.clone(),
+            comment: comment.clone(),
+        };
+
+        // Test public_key() returns borrowed reference
+        let retrieved_key = identity.public_key();
+        assert!(matches!(retrieved_key, Cow::Borrowed(_)));
+        assert_eq!(retrieved_key.key_data(), key.key_data());
+
+        // Test comment()
+        assert_eq!(identity.comment(), "test-key-comment");
+    }
+
+    #[test]
+    fn test_agent_identity_certificate_variant() {
+        let cert = create_test_certificate();
+        let comment = "test-cert-comment".to_string();
+
+        let identity = AgentIdentity::Certificate {
+            certificate: cert.clone(),
+            comment: comment.clone(),
+        };
+
+        // Test public_key() returns owned value extracted from cert
+        let retrieved_key = identity.public_key();
+        assert!(matches!(retrieved_key, Cow::Owned(_)));
+        assert_eq!(retrieved_key.key_data(), cert.public_key());
+
+        // Test comment()
+        assert_eq!(identity.comment(), "test-cert-comment");
+    }
+
+    #[test]
+    fn test_agent_identity_clone() {
+        let key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519)
+            .unwrap()
+            .public_key()
+            .clone();
+
+        let identity = AgentIdentity::PublicKey {
+            key,
+            comment: "cloneable".to_string(),
+        };
+
+        let cloned = identity.clone();
+        assert_eq!(cloned.comment(), identity.comment());
+    }
+
+    #[test]
+    fn test_agent_identity_debug() {
+        let key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519)
+            .unwrap()
+            .public_key()
+            .clone();
+
+        let identity = AgentIdentity::PublicKey {
+            key,
+            comment: "debug-test".to_string(),
+        };
+
+        // Just verify Debug is implemented and doesn't panic
+        let debug_str = format!("{:?}", identity);
+        assert!(debug_str.contains("PublicKey"));
+    }
+}
diff --git a/crates/bssh-russh/src/keys/agent/server.rs b/crates/bssh-russh/src/keys/agent/server.rs
index 58bcbe66..58c32b4e 100644
--- a/crates/bssh-russh/src/keys/agent/server.rs
+++ b/crates/bssh-russh/src/keys/agent/server.rs
@@ -66,15 +66,13 @@ where
     let keys = KeyStore(Arc::new(RwLock::new(HashMap::new())));
     let lock = Lock(Arc::new(RwLock::new(CryptoVec::new())));
     while let Some(Ok(stream)) = listener.next().await {
-        let mut buf = CryptoVec::new();
-        buf.resize(4);
         russh_util::runtime::spawn(
             (Connection {
                 lock: lock.clone(),
                 keys: keys.clone(),
                 agent: Some(agent.clone()),
                 s: stream,
-                buf: CryptoVec::new(),
+                buf: Vec::new(),
             })
             .run(),
         );
@@ -93,23 +91,23 @@ struct Connection<S: AsyncRead + AsyncWrite + Send + 'static, A: Agent> {
     keys: KeyStore,
     agent: Option<A>,
     s: S,
-    buf: CryptoVec,
+    buf: Vec<u8>,
 }
 
 impl<S: AsyncRead + AsyncWrite + Send + Unpin + 'static, A: Agent + Send + Sync + 'static>
     Connection<S, A>
 {
     async fn run(mut self) -> Result<(), Error> {
-        let mut writebuf = CryptoVec::new();
+        let mut writebuf = Vec::new();
         loop {
             // Reading the length
             self.buf.clear();
-            self.buf.resize(4);
+            self.buf.resize(4, 0);
             self.s.read_exact(&mut self.buf).await?;
             // Reading the rest of the buffer
             let len = BigEndian::read_u32(&self.buf) as usize;
             self.buf.clear();
-            self.buf.resize(len);
+            self.buf.resize(len, 0);
             self.s.read_exact(&mut self.buf).await?;
             // respond
             writebuf.clear();
@@ -119,7 +117,7 @@ impl<S: AsyncRead + AsyncWrite + Send + Unpin + 'static, A: Agent + Send + Sync
         }
     }
 
-    async fn respond(&mut self, writebuf: &mut CryptoVec) -> Result<(), Error> {
+    async fn respond(&mut self, writebuf: &mut Vec<u8>) -> Result<(), Error> {
         let is_locked = {
             if let Ok(password) = self.lock.0.read() {
                 !password.is_empty()
@@ -127,7 +125,7 @@ impl<S: AsyncRead + AsyncWrite + Send + Unpin + 'static, A: Agent + Send + Sync
                 true
             }
         };
-        writebuf.extend(&[0, 0, 0, 0]);
+        writebuf.extend_from_slice(&[0, 0, 0, 0]);
         let agentref = self.agent.as_ref().ok_or(Error::AgentFailure)?;
 
         match self.buf.split_first() {
@@ -156,7 +154,7 @@ impl<S: AsyncRead + AsyncWrite + Send + Unpin + 'static, A: Agent + Send + Sync
                 if signed {
                     return Ok(());
                 } else {
-                    writebuf.resize(4);
+                    writebuf.resize(4, 0);
                     writebuf.push(msg::FAILURE)
                 }
             }
@@ -263,7 +261,7 @@ impl<S: AsyncRead + AsyncWrite + Send + Unpin + 'static, A: Agent + Send + Sync
         &self,
         r: &mut R,
         constrained: bool,
-        writebuf: &mut CryptoVec,
+        writebuf: &mut Vec<u8>,
     ) -> Result<bool, Error> {
         let (blob, key_pair) = {
             let private_key =
@@ -313,7 +311,7 @@ impl<S: AsyncRead + AsyncWrite + Send + Unpin + 'static, A: Agent + Send + Sync
         &self,
         agent: A,
         r: &mut R,
-        writebuf: &mut CryptoVec,
+        writebuf: &mut Vec<u8>,
     ) -> Result<(A, bool), Error> {
         let mut needs_confirm = false;
         let key = {
diff --git a/crates/bssh-russh/src/keys/format/pkcs8.rs b/crates/bssh-russh/src/keys/format/pkcs8.rs
index cd8b4ddf..78eb1e11 100644
--- a/crates/bssh-russh/src/keys/format/pkcs8.rs
+++ b/crates/bssh-russh/src/keys/format/pkcs8.rs
@@ -9,6 +9,7 @@ use ssh_key::PrivateKey;
 use ssh_key::private::{EcdsaKeypair, Ed25519Keypair, Ed25519PrivateKey, KeypairData};
 
 use crate::keys::Error;
+use crate::keys::key::safe_rng;
 
 /// Decode a PKCS#8-encoded private key (ASN.1 or X9.62)
 pub fn decode_pkcs8(
@@ -118,7 +119,7 @@ pub fn encode_pkcs8_encrypted(
     let pvi = PrivateKeyInfo::try_from(pvi_bytes.as_slice())?;
 
     use rand::RngCore;
-    let mut rng = rand::thread_rng();
+    let mut rng = safe_rng();
     let mut salt = [0; 64];
     rng.fill_bytes(&mut salt);
     let mut iv = [0; 16];
diff --git a/crates/bssh-russh/src/keys/key.rs b/crates/bssh-russh/src/keys/key.rs
index 344500c7..de82cb13 100644
--- a/crates/bssh-russh/src/keys/key.rs
+++ b/crates/bssh-russh/src/keys/key.rs
@@ -1,3 +1,4 @@
+use rand::rng;
 // Copyright 2016 Pierre-Étienne Meunier
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -41,8 +42,8 @@ pub fn parse_public_key(mut p: &[u8]) -> Result<PublicKey, Error> {
 }
 
 /// Obtain a cryptographic-safe random number generator.
-pub fn safe_rng() -> impl rand::CryptoRng + rand::RngCore {
-    rand::thread_rng()
+pub fn safe_rng() -> impl rand::CryptoRng {
+    rng()
 }
 
 mod private_key_with_hash_alg {
diff --git a/crates/bssh-russh/src/keys/known_hosts.rs b/crates/bssh-russh/src/keys/known_hosts.rs
index 92501ff4..058f36f5 100644
--- a/crates/bssh-russh/src/keys/known_hosts.rs
+++ b/crates/bssh-russh/src/keys/known_hosts.rs
@@ -2,6 +2,7 @@ use std::borrow::Cow;
 use std::fs::{File, OpenOptions};
 use std::io::{BufRead, BufReader, Read, Seek, SeekFrom, Write};
 use std::path::{Path, PathBuf};
+use std::env;
 
 use data_encoding::BASE64_MIME;
 use hmac::{Hmac, Mac};
@@ -48,7 +49,7 @@ pub fn check_known_hosts_path<P: AsRef<Path>>(
 }
 
 fn known_hosts_path() -> Result<PathBuf, Error> {
-    home::home_dir()
+    env::home_dir()
         .map(|home_dir| home_dir.join(".ssh").join("known_hosts"))
         .ok_or(Error::NoHomeDir)
 }
diff --git a/crates/bssh-russh/src/keys/mod.rs b/crates/bssh-russh/src/keys/mod.rs
index dca090cd..21e011bf 100644
--- a/crates/bssh-russh/src/keys/mod.rs
+++ b/crates/bssh-russh/src/keys/mod.rs
@@ -44,8 +44,8 @@
 //!        let mut client = agent::client::AgentClient::connect(stream);
 //!        client.add_identity(&key, &[agent::Constraint::KeyLifetime { seconds: 60 }]).await?;
 //!        client.request_identities().await?;
-//!        let buf = b"signed message";
-//!        let sig = client.sign_request(&public, None, russh_cryptovec::CryptoVec::from_slice(&buf[..])).await.unwrap();
+//!        let buf = b"signed message".to_vec();
+//!        let sig = client.sign_request(&public.into(), None, buf).await.unwrap();
 //!        // Here, `sig` is encoded in a format usable internally by the SSH protocol.
 //!        Ok::<(), Error>(())
 //!    }).unwrap()
@@ -285,6 +285,8 @@ mod test {
     use futures::Future;
 
     use super::*;
+    #[cfg(unix)]
+    use crate::keys::agent::AgentIdentity;
     use crate::keys::key::PublicKeyExt;
 
     const ED25519_KEY: &str = "-----BEGIN OPENSSH PRIVATE KEY-----
@@ -861,10 +863,14 @@ Cog3JMeTrb3LiPHgN6gU2P30MRp6L1j1J/MtlOAr5rux
         let mut client = agent::client::AgentClient::connect(stream);
         client.add_identity(&key, &[]).await?;
         client.request_identities().await?;
-        let buf = russh_cryptovec::CryptoVec::from_slice(b"blabla");
+        let buf = b"blabla".to_vec();
         let len = buf.len();
         let buf = client
-            .sign_request(public, Some(HashAlg::Sha256), buf)
+            .sign_request(
+                &AgentIdentity::from(public.clone()),
+                Some(HashAlg::Sha256),
+                buf,
+            )
             .await
             .unwrap();
         let (a, b) = buf.split_at(len);
@@ -954,9 +960,12 @@ Cog3JMeTrb3LiPHgN6gU2P30MRp6L1j1J/MtlOAr5rux
                 .await
                 .unwrap();
             client.request_identities().await.unwrap();
-            let buf = russh_cryptovec::CryptoVec::from_slice(b"blabla");
+            let buf = b"blabla".to_vec();
             let len = buf.len();
-            let buf = client.sign_request(public, None, buf).await.unwrap();
+            let buf = client
+                .sign_request(&AgentIdentity::from(public.clone()), None, buf)
+                .await
+                .unwrap();
             let (a, b) = buf.split_at(len);
             if let ssh_key::public::KeyData::Ed25519 { .. } = public.key_data() {
                 let sig = &b[b.len() - 64..];
@@ -983,4 +992,587 @@ Cog3JMeTrb3LiPHgN6gU2P30MRp6L1j1J/MtlOAr5rux
             std::task::Poll::Ready(Some(Ok(sock)))
         }
     }
+
+    /// Helper to spawn an ssh-agent and return the agent process and socket path
+    #[cfg(unix)]
+    async fn spawn_agent() -> Result<
+        (tokio::process::Child, std::path::PathBuf, tempfile::TempDir),
+        Box<dyn std::error::Error>,
+    > {
+        use std::process::Stdio;
+
+        let dir = tempfile::tempdir()?;
+        let agent_path = dir.path().join("agent");
+        let agent = tokio::process::Command::new("ssh-agent")
+            .arg("-a")
+            .arg(&agent_path)
+            .arg("-D")
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn()?;
+
+        // Wait for the socket to be created
+        while agent_path.canonicalize().is_err() {
+            tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+        }
+
+        Ok((agent, agent_path, dir))
+    }
+
+    /// Helper to create a test certificate
+    #[cfg(unix)]
+    fn create_test_cert(ca_key: &PrivateKey, user_key: &PrivateKey) -> ssh_key::Certificate {
+        use ssh_key::certificate;
+        use ssh_key::rand_core::OsRng;
+        use std::time::{SystemTime, UNIX_EPOCH};
+
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        let valid_after = now - 3600; // 1 hour ago
+        let valid_before = now + 86400 * 365; // 1 year from now
+
+        let mut builder = certificate::Builder::new_with_random_nonce(
+            &mut OsRng,
+            user_key.public_key(),
+            valid_after,
+            valid_before,
+        )
+        .unwrap();
+
+        builder.serial(1).unwrap();
+        builder.key_id("test-cert").unwrap();
+        builder.cert_type(certificate::CertType::User).unwrap();
+        builder.valid_principal("testuser").unwrap();
+        builder.sign(ca_key).unwrap()
+    }
+
+    #[tokio::test]
+    #[cfg(unix)]
+    async fn test_request_identities_full_with_keys_and_certs() {
+        use crate::keys::agent::{AgentIdentity, client::AgentClient};
+        use ssh_key::rand_core::OsRng;
+        use std::io::Write;
+        use std::process::Stdio;
+
+        env_logger::try_init().unwrap_or(());
+
+        let (mut agent, agent_path, dir) = spawn_agent().await.unwrap();
+
+        // Create a CA key and user key
+        let ca_key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap();
+        let user_key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap();
+        let plain_key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap();
+
+        // Create a certificate
+        let cert = create_test_cert(&ca_key, &user_key);
+
+        // Write the keys and certificate to temp files
+        let user_key_path = dir.path().join("user_key");
+        let cert_path = dir.path().join("user_key-cert.pub");
+        let plain_key_path = dir.path().join("plain_key");
+
+        // Write user key (the one to be certified)
+        let mut f = std::fs::File::create(&user_key_path).unwrap();
+        f.write_all(
+            user_key
+                .to_openssh(ssh_key::LineEnding::LF)
+                .unwrap()
+                .as_bytes(),
+        )
+        .unwrap();
+        std::fs::set_permissions(
+            &user_key_path,
+            std::os::unix::fs::PermissionsExt::from_mode(0o600),
+        )
+        .unwrap();
+
+        // Write certificate
+        let mut f = std::fs::File::create(&cert_path).unwrap();
+        f.write_all(cert.to_openssh().unwrap().as_bytes()).unwrap();
+
+        // Write plain key
+        let mut f = std::fs::File::create(&plain_key_path).unwrap();
+        f.write_all(
+            plain_key
+                .to_openssh(ssh_key::LineEnding::LF)
+                .unwrap()
+                .as_bytes(),
+        )
+        .unwrap();
+        std::fs::set_permissions(
+            &plain_key_path,
+            std::os::unix::fs::PermissionsExt::from_mode(0o600),
+        )
+        .unwrap();
+
+        // Use ssh-add to add the certificate (it will pick up user_key-cert.pub automatically)
+        let status = tokio::process::Command::new("ssh-add")
+            .arg(&user_key_path)
+            .env("SSH_AUTH_SOCK", &agent_path)
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status()
+            .await
+            .unwrap();
+        assert!(status.success(), "ssh-add for certificate failed");
+
+        // Add plain key
+        let status = tokio::process::Command::new("ssh-add")
+            .arg(&plain_key_path)
+            .env("SSH_AUTH_SOCK", &agent_path)
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status()
+            .await
+            .unwrap();
+        assert!(status.success(), "ssh-add for plain key failed");
+
+        // Connect to agent and test request_identities_full
+        let stream = tokio::net::UnixStream::connect(&agent_path).await.unwrap();
+        let mut client = AgentClient::connect(stream);
+
+        let identities = client.request_identities().await.unwrap();
+
+        // ssh-add with a certificate adds the cert identity, and the plain key adds another
+        // The exact count depends on ssh-agent behavior - just verify we have both types
+        assert!(!identities.is_empty(), "Expected at least one identity");
+
+        // Count the types
+        let mut key_count = 0;
+        let mut cert_count = 0;
+
+        for identity in &identities {
+            match identity {
+                AgentIdentity::PublicKey { .. } => key_count += 1,
+                AgentIdentity::Certificate { certificate: c, .. } => {
+                    cert_count += 1;
+                    // Verify the certificate matches what we created
+                    assert_eq!(c.key_id(), "test-cert");
+                    // Verify public_key() works
+                    let pk = identity.public_key();
+                    assert_eq!(pk.key_data(), c.public_key());
+                }
+            }
+            // Verify comment() works
+            let _ = identity.comment();
+        }
+
+        // We should have at least one of each (ssh-add may add both key and cert for the same identity)
+        assert!(
+            key_count >= 1,
+            "Expected at least 1 public key, got {}",
+            key_count
+        );
+        assert!(
+            cert_count >= 1,
+            "Expected at least 1 certificate, got {}",
+            cert_count
+        );
+
+        agent.kill().await.unwrap();
+        agent.wait().await.unwrap();
+    }
+
+    #[tokio::test]
+    #[cfg(unix)]
+    async fn test_sign_request_cert() {
+        use crate::keys::agent::client::AgentClient;
+        use ssh_key::rand_core::OsRng;
+        use std::io::Write;
+        use std::process::Stdio;
+
+        env_logger::try_init().unwrap_or(());
+
+        let (mut agent, agent_path, dir) = spawn_agent().await.unwrap();
+
+        // Create a CA key and user key
+        let ca_key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap();
+        let user_key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap();
+
+        // Create a certificate
+        let cert = create_test_cert(&ca_key, &user_key);
+
+        // Write the key and certificate to temp files
+        let user_key_path = dir.path().join("user_key");
+        let cert_path = dir.path().join("user_key-cert.pub");
+
+        let mut f = std::fs::File::create(&user_key_path).unwrap();
+        f.write_all(
+            user_key
+                .to_openssh(ssh_key::LineEnding::LF)
+                .unwrap()
+                .as_bytes(),
+        )
+        .unwrap();
+        std::fs::set_permissions(
+            &user_key_path,
+            std::os::unix::fs::PermissionsExt::from_mode(0o600),
+        )
+        .unwrap();
+
+        let mut f = std::fs::File::create(&cert_path).unwrap();
+        f.write_all(cert.to_openssh().unwrap().as_bytes()).unwrap();
+
+        // Use ssh-add to add the certificate
+        let status = tokio::process::Command::new("ssh-add")
+            .arg(&user_key_path)
+            .env("SSH_AUTH_SOCK", &agent_path)
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status()
+            .await
+            .unwrap();
+        assert!(status.success(), "ssh-add failed");
+
+        // Connect to agent and test sign_request_cert
+        let stream = tokio::net::UnixStream::connect(&agent_path).await.unwrap();
+        let mut client = AgentClient::connect(stream);
+
+        // Create data to sign
+        let data_to_sign = b"test data to sign";
+        let buf = data_to_sign.to_vec();
+        let len = buf.len();
+
+        // Sign using the certificate (None for hash_alg since Ed25519 doesn't need it)
+        let signed_buf = client.sign_request(&cert.into(), None, buf).await.unwrap();
+
+        // Verify the signature is appended to the original data
+        assert!(signed_buf.len() > len, "Signed buffer should be larger");
+
+        // Extract and verify signature
+        let (original, sig_data) = signed_buf.split_at(len);
+        assert_eq!(original, data_to_sign);
+
+        // The signature should be valid
+        // For ed25519, signature is 64 bytes, but encoded with type prefix
+        assert!(sig_data.len() > 64, "Signature data should include type");
+
+        agent.kill().await.unwrap();
+        agent.wait().await.unwrap();
+    }
+
+    #[tokio::test]
+    #[cfg(unix)]
+    async fn test_sign_request_cert_missing_key_returns_agent_failure() {
+        use crate::keys::agent::client::AgentClient;
+        use ssh_key::rand_core::OsRng;
+
+        env_logger::try_init().unwrap_or(());
+
+        let (mut agent, agent_path, _dir) = spawn_agent().await.unwrap();
+
+        // Create a CA key and user key, but DON'T add them to the agent
+        let ca_key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap();
+        let user_key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap();
+
+        // Create a certificate
+        let cert = create_test_cert(&ca_key, &user_key);
+
+        // Connect to agent WITHOUT adding any keys
+        let stream = tokio::net::UnixStream::connect(&agent_path).await.unwrap();
+        let mut client = AgentClient::connect(stream);
+
+        // Verify the agent has no keys
+        let identities = client.request_identities().await.unwrap();
+        assert!(identities.is_empty(), "Agent should have no keys");
+
+        // Create data to sign
+        let data_to_sign = b"test data to sign";
+        let buf = data_to_sign.to_vec();
+
+        // Try to sign using the certificate - should fail because the key isn't in the agent
+        let result = client.sign_request(&cert.into(), None, buf).await;
+
+        // Verify we get an AgentFailure error
+        assert!(
+            result.is_err(),
+            "Signing should fail when key is not in agent"
+        );
+        match result {
+            Err(Error::AgentFailure) => {
+                // This is the expected error
+            }
+            Err(e) => {
+                panic!("Expected AgentFailure error, got: {:?}", e);
+            }
+            Ok(_) => {
+                panic!("Expected error, but signing succeeded");
+            }
+        }
+
+        agent.kill().await.unwrap();
+        agent.wait().await.unwrap();
+    }
+
+    #[tokio::test]
+    #[cfg(unix)]
+    async fn test_sign_request_missing_key_returns_agent_failure() {
+        use crate::keys::agent::client::AgentClient;
+        use ssh_key::rand_core::OsRng;
+
+        env_logger::try_init().unwrap_or(());
+
+        let (mut agent, agent_path, _dir) = spawn_agent().await.unwrap();
+
+        // Create a key but DON'T add it to the agent
+        let key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap();
+
+        // Connect to agent WITHOUT adding any keys
+        let stream = tokio::net::UnixStream::connect(&agent_path).await.unwrap();
+        let mut client = AgentClient::connect(stream);
+
+        // Verify the agent has no keys
+        let identities = client.request_identities().await.unwrap();
+        assert!(identities.is_empty(), "Agent should have no keys");
+
+        // Create data to sign
+        let data_to_sign = b"test data to sign";
+        let buf = data_to_sign.to_vec();
+
+        // Try to sign using the public key - should fail because the key isn't in the agent
+        let result = client
+            .sign_request(&key.public_key().clone().into(), None, buf)
+            .await;
+
+        // Verify we get an AgentFailure error
+        assert!(
+            result.is_err(),
+            "Signing should fail when key is not in agent"
+        );
+        match result {
+            Err(Error::AgentFailure) => {
+                // This is the expected error
+            }
+            Err(e) => {
+                panic!("Expected AgentFailure error, got: {:?}", e);
+            }
+            Ok(_) => {
+                panic!("Expected error, but signing succeeded");
+            }
+        }
+
+        agent.kill().await.unwrap();
+        agent.wait().await.unwrap();
+    }
+
+    /// Helper to create a test RSA certificate
+    #[cfg(all(unix, feature = "rsa"))]
+    fn create_test_rsa_cert(ca_key: &PrivateKey, user_key: &PrivateKey) -> ssh_key::Certificate {
+        use ssh_key::certificate;
+        use ssh_key::rand_core::OsRng;
+        use std::time::{SystemTime, UNIX_EPOCH};
+
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        let valid_after = now - 3600; // 1 hour ago
+        let valid_before = now + 86400 * 365; // 1 year from now
+
+        let mut builder = certificate::Builder::new_with_random_nonce(
+            &mut OsRng,
+            user_key.public_key(),
+            valid_after,
+            valid_before,
+        )
+        .unwrap();
+
+        builder.serial(1).unwrap();
+        builder.key_id("test-rsa-cert").unwrap();
+        builder.cert_type(certificate::CertType::User).unwrap();
+        builder.valid_principal("testuser").unwrap();
+        builder.sign(ca_key).unwrap()
+    }
+
+    #[tokio::test]
+    #[cfg(all(unix, feature = "rsa"))]
+    async fn test_sign_request_cert_rsa() {
+        use crate::keys::agent::client::AgentClient;
+        use ssh_key::rand_core::OsRng;
+        use std::io::Write;
+        use std::process::Stdio;
+
+        env_logger::try_init().unwrap_or(());
+
+        let (mut agent, agent_path, dir) = spawn_agent().await.unwrap();
+
+        // Create RSA CA key and user key
+        let ca_key = PrivateKey::random(
+            &mut OsRng,
+            ssh_key::Algorithm::Rsa {
+                hash: Some(HashAlg::Sha256),
+            },
+        )
+        .unwrap();
+        let user_key = PrivateKey::random(
+            &mut OsRng,
+            ssh_key::Algorithm::Rsa {
+                hash: Some(HashAlg::Sha256),
+            },
+        )
+        .unwrap();
+
+        // Create a certificate
+        let cert = create_test_rsa_cert(&ca_key, &user_key);
+
+        // Write the key and certificate to temp files
+        let user_key_path = dir.path().join("user_rsa_key");
+        let cert_path = dir.path().join("user_rsa_key-cert.pub");
+
+        let mut f = std::fs::File::create(&user_key_path).unwrap();
+        f.write_all(
+            user_key
+                .to_openssh(ssh_key::LineEnding::LF)
+                .unwrap()
+                .as_bytes(),
+        )
+        .unwrap();
+        std::fs::set_permissions(
+            &user_key_path,
+            std::os::unix::fs::PermissionsExt::from_mode(0o600),
+        )
+        .unwrap();
+
+        let mut f = std::fs::File::create(&cert_path).unwrap();
+        f.write_all(cert.to_openssh().unwrap().as_bytes()).unwrap();
+
+        // Use ssh-add to add the certificate
+        let status = tokio::process::Command::new("ssh-add")
+            .arg(&user_key_path)
+            .env("SSH_AUTH_SOCK", &agent_path)
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status()
+            .await
+            .unwrap();
+        assert!(status.success(), "ssh-add failed");
+
+        // Connect to agent and test sign_request_cert
+        let stream = tokio::net::UnixStream::connect(&agent_path).await.unwrap();
+        let mut client = AgentClient::connect(stream);
+
+        // Create data to sign
+        let data_to_sign = b"test data to sign with RSA cert";
+        let buf = data_to_sign.to_vec();
+        let len = buf.len();
+
+        // Sign using the certificate with SHA-256 hash algorithm
+        let signed_buf = client
+            .sign_request(&cert.into(), Some(HashAlg::Sha256), buf)
+            .await
+            .unwrap();
+
+        // Verify the signature is appended to the original data
+        assert!(signed_buf.len() > len, "Signed buffer should be larger");
+
+        // Extract and verify signature
+        let (original, sig_data) = signed_buf.split_at(len);
+        assert_eq!(original, data_to_sign);
+
+        // The RSA signature should be substantial
+        assert!(
+            sig_data.len() > 100,
+            "RSA signature data should be substantial"
+        );
+
+        agent.kill().await.unwrap();
+        agent.wait().await.unwrap();
+    }
+
+    #[tokio::test]
+    #[cfg(all(unix, feature = "rsa"))]
+    async fn test_sign_request_cert_rsa_sha512() {
+        use crate::keys::agent::client::AgentClient;
+        use ssh_key::rand_core::OsRng;
+        use std::io::Write;
+        use std::process::Stdio;
+
+        env_logger::try_init().unwrap_or(());
+
+        let (mut agent, agent_path, dir) = spawn_agent().await.unwrap();
+
+        // Create RSA CA key and user key
+        let ca_key = PrivateKey::random(
+            &mut OsRng,
+            ssh_key::Algorithm::Rsa {
+                hash: Some(HashAlg::Sha512),
+            },
+        )
+        .unwrap();
+        let user_key = PrivateKey::random(
+            &mut OsRng,
+            ssh_key::Algorithm::Rsa {
+                hash: Some(HashAlg::Sha512),
+            },
+        )
+        .unwrap();
+
+        // Create a certificate
+        let cert = create_test_rsa_cert(&ca_key, &user_key);
+
+        // Write the key and certificate to temp files
+        let user_key_path = dir.path().join("user_rsa_key");
+        let cert_path = dir.path().join("user_rsa_key-cert.pub");
+
+        let mut f = std::fs::File::create(&user_key_path).unwrap();
+        f.write_all(
+            user_key
+                .to_openssh(ssh_key::LineEnding::LF)
+                .unwrap()
+                .as_bytes(),
+        )
+        .unwrap();
+        std::fs::set_permissions(
+            &user_key_path,
+            std::os::unix::fs::PermissionsExt::from_mode(0o600),
+        )
+        .unwrap();
+
+        let mut f = std::fs::File::create(&cert_path).unwrap();
+        f.write_all(cert.to_openssh().unwrap().as_bytes()).unwrap();
+
+        // Use ssh-add to add the certificate
+        let status = tokio::process::Command::new("ssh-add")
+            .arg(&user_key_path)
+            .env("SSH_AUTH_SOCK", &agent_path)
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status()
+            .await
+            .unwrap();
+        assert!(status.success(), "ssh-add failed");
+
+        // Connect to agent and test sign_request_cert with SHA-512
+        let stream = tokio::net::UnixStream::connect(&agent_path).await.unwrap();
+        let mut client = AgentClient::connect(stream);
+
+        // Create data to sign
+        let data_to_sign = b"test data to sign with RSA cert SHA-512";
+        let buf = data_to_sign.to_vec();
+        let len = buf.len();
+
+        // Sign using the certificate with SHA-512 hash algorithm
+        let signed_buf = client
+            .sign_request(&cert.into(), Some(HashAlg::Sha512), buf)
+            .await
+            .unwrap();
+
+        // Verify the signature is appended to the original data
+        assert!(signed_buf.len() > len, "Signed buffer should be larger");
+
+        // Extract and verify signature
+        let (original, sig_data) = signed_buf.split_at(len);
+        assert_eq!(original, data_to_sign);
+
+        // The RSA signature should be substantial
+        assert!(
+            sig_data.len() > 100,
+            "RSA signature data should be substantial"
+        );
+
+        agent.kill().await.unwrap();
+        agent.wait().await.unwrap();
+    }
 }
diff --git a/crates/bssh-russh/src/lib_inner.rs b/crates/bssh-russh/src/lib_inner.rs
index f64b0208..81370d0d 100644
--- a/crates/bssh-russh/src/lib_inner.rs
+++ b/crates/bssh-russh/src/lib_inner.rs
@@ -470,7 +470,7 @@ pub(crate) struct ChannelParams {
     #[cfg_attr(target_arch = "wasm32", allow(dead_code))]
     wants_reply: bool,
     /// (buffer, extended stream #, data offset in buffer)
-    pending_data: std::collections::VecDeque<(CryptoVec, Option<u32>, usize)>,
+    pending_data: std::collections::VecDeque<(bytes::Bytes, Option<u32>, usize)>,
     pending_eof: bool,
     pending_close: bool,
 }
@@ -482,6 +482,13 @@ impl ChannelParams {
         self.recipient_maximum_packet_size = c.maximum_packet_size;
         self.confirmed = true;
     }
+
+    pub(crate) fn take_pending_controls(&mut self) -> (bool, bool) {
+        (
+            std::mem::take(&mut self.pending_eof),
+            std::mem::take(&mut self.pending_close),
+        )
+    }
 }
 
 /// Returns `f(val)` if `val` it is [Some], or a forever pending [Future] if it is [None].
diff --git a/crates/bssh-russh/src/negotiation.rs b/crates/bssh-russh/src/negotiation.rs
index 5fa249a8..2b5b0c7f 100644
--- a/crates/bssh-russh/src/negotiation.rs
+++ b/crates/bssh-russh/src/negotiation.rs
@@ -24,10 +24,11 @@ use crate::helpers::NameList;
 use crate::kex::{
     EXTENSION_OPENSSH_STRICT_KEX_AS_CLIENT, EXTENSION_OPENSSH_STRICT_KEX_AS_SERVER, KexCause,
 };
+use crate::keys::key::safe_rng;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::server::Config;
 use crate::sshbuffer::PacketWriter;
-use crate::{AlgorithmKind, CryptoVec, Error, cipher, compression, kex, mac, msg};
+use crate::{AlgorithmKind, Error, cipher, compression, kex, mac, msg};
 
 #[cfg(target_arch = "wasm32")]
 /// WASM-only stub
@@ -418,13 +419,13 @@ pub(crate) fn write_kex(
     prefs: &Preferred,
     writer: &mut PacketWriter,
     server_config: Option<&Config>,
-) -> Result<CryptoVec, Error> {
+) -> Result<Vec<u8>, Error> {
     writer.packet(|w| {
         // buf.clear();
         msg::KEXINIT.encode(w)?;
 
         let mut cookie = [0; 16];
-        rand::thread_rng().fill_bytes(&mut cookie);
+        safe_rng().fill_bytes(&mut cookie);
         for b in cookie {
             b.encode(w)?;
         }
diff --git a/crates/bssh-russh/src/parsing.rs b/crates/bssh-russh/src/parsing.rs
index f5f6c53b..361b94c8 100644
--- a/crates/bssh-russh/src/parsing.rs
+++ b/crates/bssh-russh/src/parsing.rs
@@ -1,6 +1,6 @@
 use ssh_encoding::{Decode, Encode, Reader};
 
-use crate::{msg, CryptoVec};
+use crate::msg;
 
 use crate::map_err;
 
@@ -53,7 +53,7 @@ impl OpenChannelMessage {
     /// Pushes a confirmation that this channel was opened to the vec.
     pub fn confirm(
         &self,
-        buffer: &mut CryptoVec,
+        buffer: &mut Vec<u8>,
         sender_channel: u32,
         window_size: u32,
         packet_size: u32,
@@ -71,7 +71,7 @@ impl OpenChannelMessage {
     /// Pushes a failure message to the vec.
     pub fn fail(
         &self,
-        buffer: &mut CryptoVec,
+        buffer: &mut Vec<u8>,
         reason: u8,
         message: &[u8],
     ) -> Result<(), crate::Error> {
@@ -86,7 +86,7 @@ impl OpenChannelMessage {
     }
 
     /// Pushes an unknown type error to the vec.
-    pub fn unknown_type(&self, buffer: &mut CryptoVec) -> Result<(), crate::Error> {
+    pub fn unknown_type(&self, buffer: &mut Vec<u8>) -> Result<(), crate::Error> {
         self.fail(
             buffer,
             msg::SSH_OPEN_UNKNOWN_CHANNEL_TYPE,
diff --git a/crates/bssh-russh/src/server/encrypted.rs b/crates/bssh-russh/src/server/encrypted.rs
index 67f6c1a2..d4dcdb82 100644
--- a/crates/bssh-russh/src/server/encrypted.rs
+++ b/crates/bssh-russh/src/server/encrypted.rs
@@ -97,7 +97,9 @@ impl Session {
                 .await?;
                 self.common.auth_attempts += 1;
                 if let EncryptedState::InitCompression = enc.state {
-                    enc.client_compression.init_decompress(&mut enc.decompress);
+                    if enc.client_compression.is_deferred() {
+                        enc.client_compression.init_decompress(&mut enc.decompress);
+                    }
                     handler.auth_succeeded(self).await?;
                 }
                 Ok(())
@@ -117,15 +119,19 @@ impl Session {
                 .await?;
                 if resp {
                     enc.state = EncryptedState::InitCompression;
-                    enc.client_compression.init_decompress(&mut enc.decompress);
+                    if enc.client_compression.is_deferred() {
+                        enc.client_compression.init_decompress(&mut enc.decompress);
+                    }
                     handler.auth_succeeded(self).await
                 } else {
                     Ok(())
                 }
             }
             (EncryptedState::InitCompression, Some((msg, mut r))) => {
-                enc.server_compression
-                    .init_compress(self.common.packet_writer.compress());
+                if enc.server_compression.is_deferred() {
+                    enc.server_compression
+                        .init_compress(self.common.packet_writer.compress());
+                }
                 enc.state = EncryptedState::Authenticated;
                 self.server_read_authenticated(handler, *msg, &mut r).await
             }
@@ -140,7 +146,7 @@ impl Session {
 fn server_accept_service(
     banner: Option<String>,
     methods: MethodSet,
-    buffer: &mut CryptoVec,
+    buffer: &mut Vec<u8>,
 ) -> Result<AuthRequest, crate::Error> {
     push_packet!(buffer, {
         buffer.push(msg::SERVICE_ACCEPT);
@@ -293,7 +299,7 @@ impl Encrypted {
 }
 
 thread_local! {
-    static SIGNATURE_BUFFER: RefCell<CryptoVec> = RefCell::new(CryptoVec::new());
+    static SIGNATURE_BUFFER: RefCell<Vec<u8>> = const { RefCell::new(Vec::new()) };
 }
 
 impl Encrypted {
@@ -388,7 +394,7 @@ impl Encrypted {
                             let mut buf = buf.borrow_mut();
                             buf.clear();
                             map_err!(session_id.encode(&mut *buf))?;
-                            buf.extend(sig_init_buffer);
+                            buf.extend_from_slice(sig_init_buffer);
 
                             Ok(Verifier::verify(&pubkey, &buf, &sig).is_ok())
                         })? {
@@ -432,11 +438,11 @@ impl Encrypted {
                     let auth = handler.auth_publickey_offered(user, &pubkey).await?;
                     match auth {
                         Auth::Accept => {
-                            let mut public_key = CryptoVec::new();
-                            public_key.extend(&pubkey_key);
+                            let mut public_key = Vec::new();
+                            public_key.extend_from_slice(&pubkey_key);
 
-                            let mut algo = CryptoVec::new();
-                            algo.extend(pubkey_algo.as_bytes());
+                            let mut algo = Vec::new();
+                            algo.extend_from_slice(pubkey_algo.as_bytes());
                             debug!("pubkey_key: {pubkey_key:?}");
                             push_packet!(self.write, {
                                 self.write.push(msg::USERAUTH_PK_OK);
@@ -483,7 +489,7 @@ impl Encrypted {
 
 async fn reject_auth_request(
     until: Instant,
-    write: &mut CryptoVec,
+    write: &mut Vec<u8>,
     auth_request: &mut AuthRequest,
 ) -> Result<(), Error> {
     debug!("rejecting {auth_request:?}");
@@ -499,7 +505,7 @@ async fn reject_auth_request(
     Ok(())
 }
 
-fn server_auth_request_success(buffer: &mut CryptoVec) {
+fn server_auth_request_success(buffer: &mut Vec<u8>) {
     push_packet!(buffer, {
         buffer.push(msg::USERAUTH_SUCCESS);
     })
@@ -508,7 +514,7 @@ fn server_auth_request_success(buffer: &mut CryptoVec) {
 async fn read_userauth_info_response<H: Handler + Send, R: Reader>(
     until: Instant,
     handler: &mut H,
-    write: &mut CryptoVec,
+    write: &mut Vec<u8>,
     auth_request: &mut AuthRequest,
     user: &str,
     r: &mut R,
@@ -537,7 +543,7 @@ async fn read_userauth_info_response<H: Handler + Send, R: Reader>(
 async fn reply_userauth_info_response(
     until: Instant,
     auth_request: &mut AuthRequest,
-    write: &mut CryptoVec,
+    write: &mut Vec<u8>,
     auth: Auth,
 ) -> Result<bool, Error> {
     match auth {
@@ -596,6 +602,12 @@ impl Session {
                 if let Some(ref mut enc) = self.common.encrypted {
                     enc.channels.remove(&channel_num);
                 }
+                // Forward the close to the channel before removing it, so that
+                // consumers waiting on `Channel::wait()` receive an explicit
+                // `ChannelMsg::Close` instead of just seeing `None`.
+                if let Some(chan) = self.channels.get(&channel_num) {
+                    chan.send(ChannelMsg::Close).await.unwrap_or(())
+                }
                 self.channels.remove(&channel_num);
                 debug!("handler.channel_close {channel_num:?}");
                 handler.channel_close(channel_num, self).await
@@ -633,7 +645,7 @@ impl Session {
                     if let Some(chan) = self.channels.get(&channel_num) {
                         chan.send(ChannelMsg::ExtendedData {
                             ext,
-                            data: CryptoVec::from_slice(&data),
+                            data: data.clone(),
                         })
                         .await
                         .unwrap_or(())
@@ -642,7 +654,7 @@ impl Session {
                 } else {
                     if let Some(chan) = self.channels.get(&channel_num) {
                         chan.send(ChannelMsg::Data {
-                            data: CryptoVec::from_slice(&data),
+                            data: data.clone(),
                         })
                         .await
                         .unwrap_or(())
@@ -668,10 +680,10 @@ impl Session {
                 }
                 if let Some(chan) = self.channels.get(&channel_num) {
                     chan.window_size().update(new_size).await;
-
-                    chan.send(ChannelMsg::WindowAdjusted { new_size })
-                        .await
-                        .unwrap_or(())
+                    // Use try_send to avoid blocking the session loop when channel buffer is full.
+                    // WindowAdjusted is informational - the critical side effect (updating
+                    // WindowSizeRef and notifying ChannelTx) already happens in update().
+                    let _ = chan.try_send(ChannelMsg::WindowAdjusted { new_size });
                 }
                 debug!("handler.window_adjusted {channel_num:?}");
                 handler.window_adjusted(channel_num, new_size, self).await
diff --git a/crates/bssh-russh/src/server/kex.rs b/crates/bssh-russh/src/server/kex.rs
index 835d009f..236235d6 100644
--- a/crates/bssh-russh/src/server/kex.rs
+++ b/crates/bssh-russh/src/server/kex.rs
@@ -109,7 +109,7 @@ impl ServerKex {
                 }
 
                 let names = {
-                    self.exchange.client_kex_init.extend(&input.buffer);
+                    self.exchange.client_kex_init.extend_from_slice(&input.buffer);
                     negotiation::Server::read_kex(
                         &input.buffer,
                         &self.config.preferred,
@@ -131,7 +131,7 @@ impl ServerKex {
 
                 if kex.skip_exchange() {
                     let newkeys = compute_keys(
-                        CryptoVec::new(),
+                        Vec::new(),
                         kex,
                         names.clone(),
                         self.exchange.clone(),
@@ -235,7 +235,7 @@ impl ServerKex {
 
                 self.exchange
                     .client_ephemeral
-                    .extend(&Bytes::decode(&mut r).map_err(Into::into)?);
+                    .extend_from_slice(&Bytes::decode(&mut r).map_err(Into::into)?);
 
                 let exchange = &mut self.exchange;
                 kex.server_dh(exchange, &input.buffer)?;
@@ -262,7 +262,7 @@ impl ServerKex {
                     let mut buffer = buffer.borrow_mut();
                     buffer.clear();
 
-                    let mut pubkey_vec = CryptoVec::new();
+                    let mut pubkey_vec = Vec::new();
                     key.public_key().to_bytes()?.encode(&mut pubkey_vec)?;
 
                     let hash = kex.compute_exchange_hash(&pubkey_vec, exchange, &mut buffer)?;
@@ -336,32 +336,39 @@ impl ServerKex {
 }
 
 fn compute_keys(
-    hash: CryptoVec,
+    hash: Vec<u8>,
     kex: KexAlgorithm,
     names: Names,
     exchange: Exchange,
     session_id: Option<&CryptoVec>,
 ) -> Result<NewKeys, Error> {
-    let session_id = if let Some(session_id) = session_id {
-        session_id
-    } else {
-        &hash
+    let session_id_ref: &[u8] = match session_id {
+        Some(sid) => sid,
+        None => &hash,
     };
     // Now computing keys.
     let c = kex.compute_keys(
-        session_id,
+        session_id_ref,
         &hash,
         names.cipher,
         names.client_mac,
         names.server_mac,
         true,
     )?;
+    let session_id_cv = match session_id {
+        Some(s) => s.clone(),
+        None => {
+            let mut cv = CryptoVec::new();
+            cv.extend(&hash);
+            cv
+        }
+    };
     Ok(NewKeys {
         exchange,
         names,
         kex,
         key: 0,
         cipher: c,
-        session_id: session_id.clone(),
+        session_id: session_id_cv,
     })
 }
diff --git a/crates/bssh-russh/src/server/mod.rs b/crates/bssh-russh/src/server/mod.rs
index b6a1a2d9..b57cd074 100644
--- a/crates/bssh-russh/src/server/mod.rs
+++ b/crates/bssh-russh/src/server/mod.rs
@@ -102,11 +102,12 @@ pub struct Config {
 impl Default for Config {
     fn default() -> Config {
         Config {
-            server_id: SshId::Standard(format!(
-                "SSH-2.0-{}_{}",
+            server_id: SshId::Standard(Cow::Borrowed(concat!(
+                "SSH-2.0-",
                 env!("CARGO_PKG_NAME"),
+                "_",
                 env!("CARGO_PKG_VERSION")
-            )),
+            ))),
             methods: auth::MethodSet::all(),
             auth_rejection_time: std::time::Duration::from_secs(1),
             auth_rejection_time_initial: None,
@@ -953,12 +954,6 @@ pub trait Server {
     }
 }
 
-use std::cell::RefCell;
-thread_local! {
-    static B1: RefCell<CryptoVec> = RefCell::new(CryptoVec::new());
-    static B2: RefCell<CryptoVec> = RefCell::new(CryptoVec::new());
-}
-
 async fn start_reading<R: AsyncRead + Unpin>(
     mut stream_read: R,
     mut buffer: SSHBuffer,
@@ -1062,7 +1057,7 @@ async fn read_ssh_id<R: AsyncRead + Unpin>(
         config,
         wants_reply: false,
         disconnected: false,
-        buffer: CryptoVec::new(),
+        buffer: Vec::new(),
         strict_kex: false,
         alive_timeouts: 0,
         received_data: false,
diff --git a/crates/bssh-russh/src/server/session.rs b/crates/bssh-russh/src/server/session.rs
index 6762211d..ea7b84f6 100644
--- a/crates/bssh-russh/src/server/session.rs
+++ b/crates/bssh-russh/src/server/session.rs
@@ -23,7 +23,7 @@ pub struct Session {
     pub(crate) sender: Handle,
     pub(crate) receiver: Receiver<Msg>,
     pub(crate) target_window_size: u32,
-    pub(crate) pending_reads: Vec<CryptoVec>,
+    pub(crate) pending_reads: Vec<Vec<u8>>,
     pub(crate) pending_len: u32,
     pub(crate) channels: HashMap<ChannelId, ChannelRef>,
     pub(crate) open_global_requests: VecDeque<GlobalRequestResponse>,
@@ -101,9 +101,12 @@ pub struct Handle {
 
 impl Handle {
     /// Send data to the session referenced by this handler.
-    pub async fn data(&self, id: ChannelId, data: CryptoVec) -> Result<(), CryptoVec> {
+    pub async fn data(&self, id: ChannelId, data: impl Into<bytes::Bytes>) -> Result<(), bytes::Bytes> {
+        let data = data.into();
         self.sender
-            .send(Msg::Channel(id, ChannelMsg::Data { data }))
+            .send(Msg::Channel(id, ChannelMsg::Data {
+                data: data.clone(),
+            }))
             .await
             .map_err(|e| match e.0 {
                 Msg::Channel(_, ChannelMsg::Data { data }) => data,
@@ -116,10 +119,14 @@ impl Handle {
         &self,
         id: ChannelId,
         ext: u32,
-        data: CryptoVec,
-    ) -> Result<(), CryptoVec> {
+        data: impl Into<bytes::Bytes>,
+    ) -> Result<(), bytes::Bytes> {
+        let data = data.into();
         self.sender
-            .send(Msg::Channel(id, ChannelMsg::ExtendedData { ext, data }))
+            .send(Msg::Channel(id, ChannelMsg::ExtendedData {
+                ext,
+                data: data.clone(),
+            }))
             .await
             .map_err(|e| match e.0 {
                 Msg::Channel(_, ChannelMsg::ExtendedData { data, .. }) => data,
@@ -452,7 +459,7 @@ impl Handle {
 impl Session {
     fn maybe_decompress(&mut self, buffer: &SSHBuffer) -> Result<IncomingSshPacket, Error> {
         if let Some(ref mut enc) = self.common.encrypted {
-            let mut decomp = CryptoVec::new();
+            let mut decomp = Vec::new();
             Ok(IncomingSshPacket {
                 #[allow(clippy::indexing_slicing)] // length checked
                 buffer: enc.decompress.decompress(
@@ -502,7 +509,6 @@ impl Session {
         pin!(reading);
         let mut is_reading = None;
 
-
         #[allow(clippy::panic)] // false positive in macro
         while !self.common.disconnected {
             self.common.received_data = false;
@@ -1040,7 +1046,7 @@ impl Session {
     ///
     /// The number of bytes added to the "sending pipeline" (to be
     /// processed by the event loop) is returned.
-    pub fn data(&mut self, channel: ChannelId, data: CryptoVec) -> Result<(), Error> {
+    pub fn data(&mut self, channel: ChannelId, data: impl Into<bytes::Bytes>) -> Result<(), Error> {
         if let Some(ref mut enc) = self.common.encrypted {
             enc.data(channel, data, self.kex.active())
         } else {
@@ -1058,7 +1064,7 @@ impl Session {
         &mut self,
         channel: ChannelId,
         extended: u32,
-        data: CryptoVec,
+        data: impl Into<bytes::Bytes>,
     ) -> Result<(), Error> {
         if let Some(ref mut enc) = self.common.encrypted {
             enc.extended_data(channel, extended, data, self.kex.active())
@@ -1260,7 +1266,7 @@ impl Session {
 
     fn channel_open_generic<F>(&mut self, kind: &[u8], write_suffix: F) -> Result<ChannelId, Error>
     where
-        F: FnOnce(&mut CryptoVec) -> Result<(), Error>,
+        F: FnOnce(&mut Vec<u8>) -> Result<(), Error>,
     {
         let result = if let Some(ref mut enc) = self.common.encrypted {
             if !matches!(
@@ -1374,7 +1380,7 @@ impl Session {
             // If client sent a ext-info-c message in the kex list, it supports RFC 8308 extension negotiation.
             let mut key_extension_client = false;
             if let Some(e) = &enc.exchange {
-                let &Some(mut r) = &e.client_kex_init.as_ref().get(17..) else {
+                let Some(mut r) = e.client_kex_init.get(17..) else {
                     return Ok(());
                 };
                 if let Ok(kex_string) = String::decode(&mut r) {
diff --git a/crates/bssh-russh/src/session.rs b/crates/bssh-russh/src/session.rs
index ed8bf291..50a82bdb 100644
--- a/crates/bssh-russh/src/session.rs
+++ b/crates/bssh-russh/src/session.rs
@@ -45,7 +45,10 @@ pub(crate) struct Encrypted {
     pub session_id: CryptoVec,
     pub channels: HashMap<ChannelId, ChannelParams>,
     pub last_channel_id: Wrapping<u32>,
-    pub write: CryptoVec,
+    // Non-sensitive packet assembly buffer, analogous to
+    // OpenSSH sshbuf (output side).  Not mlocked because it
+    // holds only protocol framing and ciphertext.
+    pub write: Vec<u8>,
     pub write_cursor: usize,
     pub last_rekey: russh_util::time::Instant,
     pub server_compression: crate::compression::Compression,
@@ -68,7 +71,8 @@ pub(crate) struct CommonSession<Config> {
     pub remote_to_local: Box<dyn OpeningKey + Send>,
     pub wants_reply: bool,
     pub disconnected: bool,
-    pub buffer: CryptoVec,
+    // Non-sensitive incoming-packet scratch buffer.
+    pub buffer: Vec<u8>,
     pub strict_kex: bool,
     pub alive_timeouts: usize,
     pub received_data: bool,
@@ -93,6 +97,7 @@ impl<C> Debug for CommonSession<C> {
     }
 }
 
+#[must_use]
 #[derive(Debug, Clone, Copy)]
 pub(crate) enum ChannelFlushResult {
     Incomplete {
@@ -111,11 +116,12 @@ impl ChannelFlushResult {
             ChannelFlushResult::Complete { wrote, .. } => *wrote,
         }
     }
-    pub(crate) fn complete(wrote: usize, channel: &ChannelParams) -> Self {
+    pub(crate) fn complete(wrote: usize, channel: &mut ChannelParams) -> Self {
+        let (pending_eof, pending_close) = channel.take_pending_controls();
         ChannelFlushResult::Complete {
             wrote,
-            pending_eof: channel.pending_eof,
-            pending_close: channel.pending_close,
+            pending_eof,
+            pending_close,
         }
     }
 }
@@ -152,7 +158,7 @@ impl<C> CommonSession<C> {
             state,
             channels: HashMap::new(),
             last_channel_id: Wrapping(1),
-            write: CryptoVec::new(),
+            write: Vec::new(),
             write_cursor: 0,
             last_rekey: russh_util::time::Instant::now(),
             server_compression: newkeys.names.server_compression,
@@ -166,6 +172,20 @@ impl<C> CommonSession<C> {
         self.packet_writer
             .set_cipher(newkeys.cipher.local_to_remote);
         self.strict_kex = strict_kex;
+
+        // For non-deferred compression (RFC 4253 "zlib"), activate immediately
+        // after initial key exchange. Deferred compression ("zlib@openssh.com")
+        // will be activated later, after authentication succeeds.
+        if let Some(ref mut enc) = self.encrypted {
+            if !enc.client_compression.is_deferred() {
+                enc.client_compression
+                    .init_compress(self.packet_writer.compress());
+            }
+            if !enc.server_compression.is_deferred() {
+                enc.server_compression
+                    .init_decompress(&mut enc.decompress);
+            }
+        }
     }
 
     /// Send a disconnect message.
@@ -175,7 +195,7 @@ impl<C> CommonSession<C> {
         description: &str,
         language_tag: &str,
     ) -> Result<(), crate::Error> {
-        let disconnect = |buf: &mut CryptoVec| {
+        let disconnect = |buf: &mut Vec<u8>| {
             push_packet!(buf, {
                 msg::DISCONNECT.encode(buf)?;
                 (reason as u32).encode(buf)?;
@@ -202,7 +222,7 @@ impl<C> CommonSession<C> {
         message: &str,
         language_tag: &str,
     ) -> Result<(), crate::Error> {
-        let debug = |buf: &mut CryptoVec| {
+        let debug = |buf: &mut Vec<u8>| {
             push_packet!(buf, {
                 msg::DEBUG.encode(buf)?;
                 (always_display as u8).encode(buf)?;
@@ -295,7 +315,7 @@ impl Encrypted {
     }
 
     fn flush_channel(
-        write: &mut CryptoVec,
+        write: &mut Vec<u8>,
         channel: &mut ChannelParams,
     ) -> Result<ChannelFlushResult, crate::Error> {
         let mut pending_size = 0;
@@ -334,23 +354,19 @@ impl Encrypted {
     }
 
     pub fn flush_pending(&mut self, channel: ChannelId) -> Result<usize, crate::Error> {
-        let mut pending_size = 0;
-        let mut maybe_flush_result = Option::<ChannelFlushResult>::None;
-
-        if let Some(channel) = self.channels.get_mut(&channel) {
-            let flush_result = Self::flush_channel(&mut self.write, channel)?;
-            pending_size += flush_result.wrote();
-            maybe_flush_result = Some(flush_result);
-        }
-        if let Some(flush_result) = maybe_flush_result {
-            self.handle_flushed_channel(channel, flush_result)?
-        }
-        Ok(pending_size)
+        let flush_result = match self.channels.get_mut(&channel) {
+            Some(ch) => Self::flush_channel(&mut self.write, ch)?,
+            None => return Ok(0),
+        };
+        let wrote = flush_result.wrote();
+        self.handle_flushed_channel(channel, flush_result)?;
+        Ok(wrote)
     }
 
     pub fn flush_all_pending(&mut self) -> Result<(), crate::Error> {
-        for channel in self.channels.values_mut() {
-            Self::flush_channel(&mut self.write, channel)?;
+        let channel_ids: Vec<ChannelId> = self.channels.keys().copied().collect();
+        for channel_id in channel_ids {
+            self.flush_pending(channel_id)?;
         }
         Ok(())
     }
@@ -373,7 +389,7 @@ impl Encrypted {
     /// the window, dividing it into packets if it is too large, and
     /// return the length that was written.
     fn data_noqueue(
-        write: &mut CryptoVec,
+        write: &mut Vec<u8>,
         channel: &mut ChannelParams,
         buf0: &[u8],
         a: Option<u32>,
@@ -427,9 +443,10 @@ impl Encrypted {
     pub fn data(
         &mut self,
         channel: ChannelId,
-        buf0: CryptoVec,
+        buf0: impl Into<bytes::Bytes>,
         is_rekeying: bool,
     ) -> Result<(), crate::Error> {
+        let buf0 = buf0.into();
         if let Some(channel) = self.channels.get_mut(&channel) {
             assert!(channel.confirmed);
             if !channel.pending_data.is_empty() && is_rekeying {
@@ -450,9 +467,10 @@ impl Encrypted {
         &mut self,
         channel: ChannelId,
         ext: u32,
-        buf0: CryptoVec,
+        buf0: impl Into<bytes::Bytes>,
         is_rekeying: bool,
     ) -> Result<(), crate::Error> {
+        let buf0 = buf0.into();
         if let Some(channel) = self.channels.get_mut(&channel) {
             assert!(channel.confirmed);
             if !channel.pending_data.is_empty() && is_rekeying {
@@ -548,12 +566,15 @@ pub enum EncryptedState {
 
 #[derive(Debug, Default, Clone)]
 pub struct Exchange {
-    pub client_id: CryptoVec,
-    pub server_id: CryptoVec,
-    pub client_kex_init: CryptoVec,
-    pub server_kex_init: CryptoVec,
-    pub client_ephemeral: CryptoVec,
-    pub server_ephemeral: CryptoVec,
+    // All Exchange fields are public protocol values (identifiers,
+    // kex init payloads, ephemeral public keys) visible on the wire.
+    // They carry no secret material and do not require mlock.
+    pub client_id: Vec<u8>,
+    pub server_id: Vec<u8>,
+    pub client_kex_init: Vec<u8>,
+    pub server_kex_init: Vec<u8>,
+    pub client_ephemeral: Vec<u8>,
+    pub server_ephemeral: Vec<u8>,
     pub gex: Option<(GexParams, DhGroup)>,
 }
 
@@ -593,3 +614,226 @@ pub(crate) enum GlobalRequestResponse {
     StreamLocalForward(oneshot::Sender<bool>),
     CancelStreamLocalForward(oneshot::Sender<bool>),
 }
+
+#[cfg(test)]
+mod tests {
+    use std::collections::{HashMap, VecDeque};
+    use std::num::Wrapping;
+
+    use byteorder::{BigEndian, ByteOrder};
+    use bytes::Bytes;
+
+    use super::{Encrypted, EncryptedState, Exchange};
+    use crate::compression::{Compression, Decompress};
+    use crate::kex::{KEXES, NONE};
+    use crate::{ChannelId, ChannelParams, CryptoVec, mac, msg};
+
+    fn test_encrypted() -> Encrypted {
+        Encrypted {
+            state: EncryptedState::Authenticated,
+            exchange: Some(Exchange::default()),
+            kex: KEXES.get(&NONE).unwrap().make(),
+            key: 0,
+            client_mac: mac::NONE,
+            server_mac: mac::NONE,
+            session_id: CryptoVec::new(),
+            channels: HashMap::new(),
+            last_channel_id: Wrapping(0),
+            write: Vec::new(),
+            write_cursor: 0,
+            last_rekey: russh_util::time::Instant::now(),
+            server_compression: Compression::None,
+            client_compression: Compression::None,
+            decompress: Decompress::None,
+            rekey_wanted: false,
+            received_extensions: Vec::new(),
+            extension_info_awaiters: HashMap::new(),
+        }
+    }
+
+    fn test_channel(
+        sender_channel: ChannelId,
+        recipient_channel: u32,
+        pending_eof: bool,
+        pending_close: bool,
+    ) -> ChannelParams {
+        ChannelParams {
+            recipient_channel,
+            sender_channel,
+            recipient_window_size: 1024,
+            sender_window_size: 1024,
+            recipient_maximum_packet_size: 1024,
+            sender_maximum_packet_size: 1024,
+            confirmed: true,
+            wants_reply: false,
+            pending_data: VecDeque::from([(Bytes::from_static(b"hello"), None, 0)]),
+            pending_eof,
+            pending_close,
+        }
+    }
+
+    fn packet_types(buf: &[u8]) -> Vec<u8> {
+        let mut packet_types = Vec::new();
+        let mut cursor = 0;
+
+        while cursor < buf.len() {
+            let packet_len = BigEndian::read_u32(&buf[cursor..cursor + 4]) as usize;
+            packet_types.push(buf[cursor + 4]);
+            cursor += 4 + packet_len;
+        }
+
+        packet_types
+    }
+
+    fn test_channel_windowed(
+        sender_channel: ChannelId,
+        recipient_channel: u32,
+        window_size: u32,
+        pending_eof: bool,
+        pending_close: bool,
+    ) -> ChannelParams {
+        ChannelParams {
+            recipient_channel,
+            sender_channel,
+            recipient_window_size: window_size,
+            sender_window_size: 1024,
+            recipient_maximum_packet_size: 1024,
+            sender_maximum_packet_size: 1024,
+            confirmed: true,
+            wants_reply: false,
+            pending_data: VecDeque::from([(Bytes::from_static(b"hello"), None, 0)]),
+            pending_eof,
+            pending_close,
+        }
+    }
+
+    // flush_pending (single-channel path)
+
+    #[test]
+    fn flush_pending_replays_deferred_eof_once() {
+        let channel_id = ChannelId(10);
+        let mut encrypted = test_encrypted();
+        encrypted
+            .channels
+            .insert(channel_id, test_channel(channel_id, 42, true, false));
+
+        encrypted.flush_pending(channel_id).unwrap();
+        assert_eq!(
+            packet_types(&encrypted.write),
+            vec![msg::CHANNEL_DATA, msg::CHANNEL_EOF]
+        );
+        assert!(!encrypted.channels[&channel_id].pending_eof);
+
+        // Second flush must not re-emit EOF.
+        encrypted.flush_pending(channel_id).unwrap();
+        assert_eq!(
+            packet_types(&encrypted.write),
+            vec![msg::CHANNEL_DATA, msg::CHANNEL_EOF]
+        );
+    }
+
+    #[test]
+    fn flush_pending_replays_deferred_close_and_removes_channel() {
+        let channel_id = ChannelId(11);
+        let mut encrypted = test_encrypted();
+        encrypted
+            .channels
+            .insert(channel_id, test_channel(channel_id, 43, true, true));
+
+        encrypted.flush_pending(channel_id).unwrap();
+        assert_eq!(
+            packet_types(&encrypted.write),
+            vec![msg::CHANNEL_DATA, msg::CHANNEL_EOF, msg::CHANNEL_CLOSE]
+        );
+        assert!(!encrypted.channels.contains_key(&channel_id));
+    }
+
+    #[test]
+    fn flush_pending_no_controls_when_incomplete() {
+        // Window smaller than data: flush is incomplete, EOF/CLOSE must not be sent.
+        let channel_id = ChannelId(12);
+        let mut encrypted = test_encrypted();
+        encrypted.channels.insert(
+            channel_id,
+            test_channel_windowed(channel_id, 44, 3, true, true),
+        );
+
+        encrypted.flush_pending(channel_id).unwrap();
+        // Only partial data fits; no EOF or CLOSE yet.
+        assert_eq!(packet_types(&encrypted.write), vec![msg::CHANNEL_DATA]);
+        assert!(encrypted.channels.contains_key(&channel_id));
+        assert!(encrypted.channels[&channel_id].pending_eof);
+        assert!(encrypted.channels[&channel_id].pending_close);
+    }
+
+    // flush_all_pending (multi-channel path)
+
+    #[test]
+    fn flush_all_pending_replays_deferred_eof_once() {
+        let channel_id = ChannelId(1);
+        let mut encrypted = test_encrypted();
+        encrypted
+            .channels
+            .insert(channel_id, test_channel(channel_id, 42, true, false));
+
+        encrypted.flush_all_pending().unwrap();
+        assert_eq!(
+            packet_types(&encrypted.write),
+            vec![msg::CHANNEL_DATA, msg::CHANNEL_EOF]
+        );
+        assert!(!encrypted.channels[&channel_id].pending_eof);
+
+        encrypted.flush_all_pending().unwrap();
+        assert_eq!(
+            packet_types(&encrypted.write),
+            vec![msg::CHANNEL_DATA, msg::CHANNEL_EOF]
+        );
+    }
+
+    #[test]
+    fn flush_all_pending_replays_deferred_close_and_removes_channel() {
+        let channel_id = ChannelId(2);
+        let mut encrypted = test_encrypted();
+        encrypted
+            .channels
+            .insert(channel_id, test_channel(channel_id, 43, true, true));
+
+        encrypted.flush_all_pending().unwrap();
+        assert_eq!(
+            packet_types(&encrypted.write),
+            vec![msg::CHANNEL_DATA, msg::CHANNEL_EOF, msg::CHANNEL_CLOSE]
+        );
+        assert!(!encrypted.channels.contains_key(&channel_id));
+    }
+
+    #[test]
+    fn flush_all_pending_handles_multiple_channels_independently() {
+        let eof_only = ChannelId(3);
+        let close_too = ChannelId(4);
+        let mut encrypted = test_encrypted();
+        encrypted
+            .channels
+            .insert(eof_only, test_channel(eof_only, 50, true, false));
+        encrypted
+            .channels
+            .insert(close_too, test_channel(close_too, 51, true, true));
+
+        encrypted.flush_all_pending().unwrap();
+
+        // eof_only: data + EOF, channel still present
+        assert!(encrypted.channels.contains_key(&eof_only));
+        assert!(!encrypted.channels[&eof_only].pending_eof);
+
+        // close_too: data + EOF + CLOSE, channel removed
+        assert!(!encrypted.channels.contains_key(&close_too));
+
+        // Combined wire output contains both sets of packets (order may vary by map iteration).
+        let types = packet_types(&encrypted.write);
+        assert_eq!(types.iter().filter(|&&t| t == msg::CHANNEL_DATA).count(), 2);
+        assert_eq!(types.iter().filter(|&&t| t == msg::CHANNEL_EOF).count(), 2);
+        assert_eq!(
+            types.iter().filter(|&&t| t == msg::CHANNEL_CLOSE).count(),
+            1
+        );
+    }
+}
diff --git a/crates/bssh-russh/src/ssh_read.rs b/crates/bssh-russh/src/ssh_read.rs
index 1f04469f..3656a6af 100644
--- a/crates/bssh-russh/src/ssh_read.rs
+++ b/crates/bssh-russh/src/ssh_read.rs
@@ -4,12 +4,14 @@ use futures::task::*;
 use log::trace;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, ReadBuf};
 
-use crate::{CryptoVec, Error};
+use crate::Error;
+
+const SSH_ID_BUF_SIZE: usize = 256;
 
 /// The buffer to read the identification string (first line in the
-/// protocol).
+/// protocol).  Not sensitive data — just protocol version exchange.
 struct ReadSshIdBuffer {
-    pub buf: CryptoVec,
+    pub buf: Box<[u8; SSH_ID_BUF_SIZE]>,
     pub total: usize,
     pub bytes_read: usize,
     pub sshid_len: usize,
@@ -22,10 +24,8 @@ impl ReadSshIdBuffer {
     }
 
     pub fn new() -> ReadSshIdBuffer {
-        let mut buf = CryptoVec::new();
-        buf.resize(256);
         ReadSshIdBuffer {
-            buf,
+            buf: Box::new([0; SSH_ID_BUF_SIZE]),
             sshid_len: 0,
             bytes_read: 0,
             total: 0,
@@ -173,3 +173,113 @@ impl<R: AsyncRead + Unpin> SshRead<R> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::iter;
+
+    #[tokio::test]
+    async fn test_ssh_id_openssh() {
+        let data = "SSH-2.0-OpenSSH_10.2\r\n";
+        let mut read = SshRead::new(data.as_bytes());
+
+        let received = read.read_ssh_id().await.unwrap();
+        assert_eq!(received, b"SSH-2.0-OpenSSH_10.2");
+    }
+
+    #[tokio::test]
+    async fn test_ssh_id_openssh_7_4() {
+        let data = "SSH-2.0-OpenSSH_7.4\n";
+        let mut read = SshRead::new(data.as_bytes());
+
+        let received = read.read_ssh_id().await.unwrap();
+        assert_eq!(received, b"SSH-2.0-OpenSSH_7.4");
+    }
+
+    #[tokio::test]
+    async fn test_ssh_id_too_long() {
+        let data = String::from_iter(iter::once("SSH-2.0-").chain(
+            iter::repeat("A").take(500)));
+        let mut read = SshRead::new(data.as_bytes());
+
+        let received = read.read_ssh_id().await;
+        assert!(matches!(received.err(), Some(Error::Disconnect)));
+    }
+
+    #[tokio::test]
+    async fn test_ssh_id_empty() {
+        let data = "";
+        let mut read = SshRead::new(data.as_bytes());
+
+        let received = read.read_ssh_id().await;
+        assert!(matches!(received.err(), Some(Error::Disconnect)));
+    }
+
+    #[tokio::test]
+    async fn test_ssh_id_almost_empty_cr_nl() {
+        let data = "SSH-2.0-\n";
+        let mut read = SshRead::new(data.as_bytes());
+
+        let received = read.read_ssh_id().await.unwrap();
+        assert_eq!(received, b"SSH-2.0-");
+    }
+
+    #[tokio::test]
+    async fn test_ssh_id_almost_empty_nl() {
+        let data = "SSH-2.0-\n";
+        let mut read = SshRead::new(data.as_bytes());
+
+        let received = read.read_ssh_id().await.unwrap();
+        assert_eq!(received, b"SSH-2.0-");
+    }
+
+    #[tokio::test]
+    async fn test_ssh_id_newline() {
+        let data = "\n";
+        let mut read = SshRead::new(data.as_bytes());
+
+        let received = read.read_ssh_id().await;
+        assert!(matches!(received.err(), Some(Error::Disconnect)));
+    }
+
+    #[tokio::test]
+    async fn test_ssh_id_contains_cr() {
+        // A \r that isn't followed by \n has no special meaning
+        let data = "SSH-2.0-OpenSSH\r10.2\n";
+        let mut read = SshRead::new(data.as_bytes());
+
+        let received = read.read_ssh_id().await.unwrap();
+        assert_eq!(received, b"SSH-2.0-OpenSSH\r10.2");
+    }
+
+    #[tokio::test]
+    async fn test_ssh_id_trailing_cr() {
+        // Verify this doesn't cause an out-of-bounds access when testing for \r\n
+        let data = "SSH-2.0-OpenSSH_10.2\r";
+        let mut read = SshRead::new(data.as_bytes());
+
+        let received = read.read_ssh_id().await;
+        assert!(matches!(received.err(), Some(Error::Disconnect)));
+    }
+
+    #[tokio::test]
+    async fn test_ssh_id_nl_cr() {
+        // Like \r\n but backwards
+        let data = "SSH-2.0-OpenSSH_10.2\n\r";
+        let mut read = SshRead::new(data.as_bytes());
+
+        let received = read.read_ssh_id().await.unwrap();
+        assert_eq!(received, b"SSH-2.0-OpenSSH_10.2");
+    }
+
+    #[tokio::test]
+    async fn test_ssh_id_nl_cr_nl() {
+        // Like \r\n but backwards, but also part of \r\n
+        let data = "SSH-2.0-OpenSSH_10.2\n\r\n";
+        let mut read = SshRead::new(data.as_bytes());
+
+        let received = read.read_ssh_id().await.unwrap();
+        assert_eq!(received, b"SSH-2.0-OpenSSH_10.2");
+    }
+}
diff --git a/crates/bssh-russh/src/sshbuffer.rs b/crates/bssh-russh/src/sshbuffer.rs
index 228376b5..d7d72940 100644
--- a/crates/bssh-russh/src/sshbuffer.rs
+++ b/crates/bssh-russh/src/sshbuffer.rs
@@ -14,6 +14,7 @@
 //
 
 use core::fmt;
+use std::borrow::Cow;
 use std::num::Wrapping;
 
 use cipher::SealingKey;
@@ -26,9 +27,9 @@ use super::*;
 #[derive(Debug)]
 pub enum SshId {
     /// When sending the id, append RFC standard `\r\n`. Example: `SshId::Standard("SSH-2.0-acme")`
-    Standard(String),
+    Standard(Cow<'static, str>),
     /// When sending the id, use this buffer as it is and do not append additional line terminators.
-    Raw(String),
+    Raw(Cow<'static, str>),
 }
 
 impl SshId {
@@ -39,37 +40,41 @@ impl SshId {
         }
     }
 
-    pub(crate) fn write(&self, buffer: &mut CryptoVec) {
+    /// Write the SSH identification string to a buffer.
+    /// Buffer is not sensitive - SSH identification strings are public protocol data.
+    pub(crate) fn write(&self, buffer: &mut Vec<u8>) {
         match self {
-            Self::Standard(s) => buffer.extend(format!("{s}\r\n").as_bytes()),
-            Self::Raw(s) => buffer.extend(s.as_bytes()),
+            Self::Standard(s) => buffer.extend_from_slice(format!("{s}\r\n").as_bytes()),
+            Self::Raw(s) => buffer.extend_from_slice(s.as_bytes()),
         }
     }
 }
 
 #[test]
 fn test_ssh_id() {
-    let mut buffer = CryptoVec::new();
-    SshId::Standard("SSH-2.0-acme".to_string()).write(&mut buffer);
+    let mut buffer = Vec::new();
+    SshId::Standard("SSH-2.0-acme".into()).write(&mut buffer);
     assert_eq!(&buffer[..], b"SSH-2.0-acme\r\n");
 
-    let mut buffer = CryptoVec::new();
-    SshId::Raw("SSH-2.0-raw\n".to_string()).write(&mut buffer);
+    let mut buffer = Vec::new();
+    SshId::Raw("SSH-2.0-raw\n".into()).write(&mut buffer);
     assert_eq!(&buffer[..], b"SSH-2.0-raw\n");
 
     assert_eq!(
-        SshId::Standard("SSH-2.0-acme".to_string()).as_kex_hash_bytes(),
+        SshId::Standard("SSH-2.0-acme".into()).as_kex_hash_bytes(),
         b"SSH-2.0-acme"
     );
     assert_eq!(
-        SshId::Raw("SSH-2.0-raw\n".to_string()).as_kex_hash_bytes(),
+        SshId::Raw("SSH-2.0-raw\n".into()).as_kex_hash_bytes(),
         b"SSH-2.0-raw"
     );
 }
 
+/// SSH packet read/write buffer. Uses Vec<u8> (not CryptoVec/mlocked) because
+/// packet data is not secret material.
 #[derive(Debug, Default)]
 pub struct SSHBuffer {
-    pub buffer: CryptoVec,
+    pub buffer: Vec<u8>,
     pub len: usize,   // next packet length.
     pub bytes: usize, // total bytes written since the last rekey
     // Sequence numbers are on 32 bits and wrap.
@@ -80,7 +85,7 @@ pub struct SSHBuffer {
 impl SSHBuffer {
     pub fn new() -> Self {
         SSHBuffer {
-            buffer: CryptoVec::new(),
+            buffer: Vec::new(),
             len: 0,
             bytes: 0,
             seqn: Wrapping(0),
@@ -92,16 +97,19 @@ impl SSHBuffer {
     }
 }
 
+/// Incoming SSH packet after decryption and optional decompression.
+/// Uses Vec<u8> (not CryptoVec/mlocked) because incoming network data is not secret.
 #[derive(Debug)]
 pub(crate) struct IncomingSshPacket {
-    pub buffer: CryptoVec,
+    pub buffer: Vec<u8>,
     pub seqn: Wrapping<u32>,
 }
 
+/// Packet writer for constructing and encrypting outgoing SSH packets.
 pub(crate) struct PacketWriter {
     cipher: Box<dyn SealingKey + Send>,
     compress: Compress,
-    compress_buffer: CryptoVec,
+    compress_buffer: Vec<u8>,
     write_buffer: SSHBuffer,
 }
 
@@ -120,7 +128,7 @@ impl PacketWriter {
         Self {
             cipher,
             compress,
-            compress_buffer: CryptoVec::new(),
+            compress_buffer: Vec::new(),
             write_buffer: SSHBuffer::new(),
         }
     }
@@ -134,12 +142,13 @@ impl PacketWriter {
         Ok(())
     }
 
-    /// Sends and returns the packet contents
-    pub fn packet<F: FnOnce(&mut CryptoVec) -> Result<(), Error>>(
+    /// Sends and returns the packet contents.
+    /// Packet buffer is not secret — use Vec<u8> for performance.
+    pub fn packet<F: FnOnce(&mut Vec<u8>) -> Result<(), Error>>(
         &mut self,
         f: F,
-    ) -> Result<CryptoVec, Error> {
-        let mut buf = CryptoVec::new();
+    ) -> Result<Vec<u8>, Error> {
+        let mut buf = Vec::new();
         f(&mut buf)?;
         self.packet_raw(&buf)?;
         Ok(buf)
diff --git a/crates/bssh-russh/src/tests.rs b/crates/bssh-russh/src/tests.rs
index 6241f4c4..fe6430bc 100644
--- a/crates/bssh-russh/src/tests.rs
+++ b/crates/bssh-russh/src/tests.rs
@@ -8,9 +8,9 @@ mod compress {
     use std::collections::HashMap;
     use std::sync::{Arc, Mutex};
 
+    use crate::keys::ssh_key::rand_core::OsRng;
     use keys::PrivateKeyWithHashAlg;
     use log::debug;
-    use rand_core::OsRng;
     use ssh_key::PrivateKey;
 
     use super::server::{Server as _, Session};
@@ -118,7 +118,7 @@ mod compress {
             session: &mut Session,
         ) -> Result<(), Self::Error> {
             debug!("server data = {:?}", std::str::from_utf8(data));
-            session.data(channel, CryptoVec::from_slice(data))?;
+            session.data(channel, data.to_vec())?;
             Ok(())
         }
     }
@@ -139,14 +139,13 @@ mod compress {
 }
 
 mod channels {
+    use elliptic_curve::rand_core::OsRng;
     use keys::PrivateKeyWithHashAlg;
-    use rand_core::OsRng;
     use server::Session;
     use ssh_key::PrivateKey;
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
     use super::*;
-    use crate::CryptoVec;
 
     async fn test_session<RC, RS, CH, SH, F1, F2>(
         client_handler: CH,
@@ -237,7 +236,7 @@ mod channels {
                 session: &mut client::Session,
             ) -> Result<(), Self::Error> {
                 assert_eq!(data, &b"hello world!"[..]);
-                session.data(channel, CryptoVec::from_slice(&b"hey there!"[..]))?;
+                session.data(channel, b"hey there!".to_vec())?;
                 Ok(())
             }
         }
@@ -285,7 +284,7 @@ mod channels {
 
                 let msg = ch.wait().await.unwrap();
                 if let ChannelMsg::Data { data } = msg {
-                    assert_eq!(data.as_ref(), &b"hey there!"[..]);
+                    assert_eq!(&data[..], &b"hey there!"[..]);
                 } else {
                     panic!("Unexpected message {msg:?}");
                 }
@@ -451,11 +450,18 @@ mod channels {
 
                 let msg = ch.wait().await.unwrap();
                 if let ChannelMsg::Data { data } = msg {
-                    assert_eq!(data.as_ref(), &b"hello world!"[..]);
+                    assert_eq!(&data[..], &b"hello world!"[..]);
                 } else {
                     panic!("Unexpected message {msg:?}");
                 }
 
+                // After the server closes the channel, we should receive an
+                // explicit Close message before the channel stream ends.
+                let msg = ch.wait().await.unwrap();
+                assert!(
+                    matches!(msg, ChannelMsg::Close),
+                    "expected Close, got {msg:?}"
+                );
                 assert!(ch.wait().await.is_none());
                 c
             },
@@ -464,6 +470,78 @@ mod channels {
         .await;
     }
 
+    /// Verify that the server-side CHANNEL_CLOSE handler delivers
+    /// `ChannelMsg::Close` before the channel stream ends.
+    #[tokio::test]
+    async fn test_server_receives_close_on_client_close() {
+        #[derive(Debug)]
+        struct Client {}
+
+        impl client::Handler for Client {
+            type Error = crate::Error;
+
+            async fn check_server_key(
+                &mut self,
+                _server_public_key: &crate::keys::ssh_key::PublicKey,
+            ) -> Result<bool, Self::Error> {
+                Ok(true)
+            }
+        }
+
+        struct ServerHandle {
+            channel: Option<tokio::sync::oneshot::Sender<Channel<server::Msg>>>,
+        }
+
+        impl server::Handler for ServerHandle {
+            type Error = crate::Error;
+
+            async fn auth_publickey(
+                &mut self,
+                _: &str,
+                _: &crate::keys::ssh_key::PublicKey,
+            ) -> Result<server::Auth, Self::Error> {
+                Ok(server::Auth::Accept)
+            }
+
+            async fn channel_open_session(
+                &mut self,
+                channel: Channel<server::Msg>,
+                _session: &mut server::Session,
+            ) -> Result<bool, Self::Error> {
+                if let Some(tx) = self.channel.take() {
+                    tx.send(channel).unwrap();
+                }
+                Ok(true)
+            }
+        }
+
+        let (tx, rx) = tokio::sync::oneshot::channel::<Channel<server::Msg>>();
+        let sh = ServerHandle { channel: Some(tx) };
+
+        test_session(
+            Client {},
+            sh,
+            |c| async move {
+                let ch = c.channel_open_session().await.unwrap();
+                ch.close().await.unwrap();
+                c
+            },
+            |s| async move {
+                let mut ch = rx.await.unwrap();
+                // The server should receive an explicit Close message
+                // when the client closes the channel.
+                let msg = ch.wait().await.unwrap();
+                assert!(
+                    matches!(msg, ChannelMsg::Close),
+                    "expected Close, got {msg:?}"
+                );
+                assert!(ch.wait().await.is_none());
+                s
+            },
+        )
+        .await;
+    }
+
     #[tokio::test]
     async fn test_channel_window_size() {
         #[derive(Debug)]
@@ -617,3 +695,215 @@ mod server_kex_junk {
         type Error = super::Error;
     }
 }
+
+/// Integration test for FutureCertificate authentication flow
+#[cfg(unix)]
+mod future_certificate {
+    use std::io::Write;
+    use std::process::Stdio;
+    use std::sync::Arc;
+
+    use ssh_key::{certificate, PrivateKey};
+    use ssh_key::rand_core::OsRng;
+
+    use crate::keys::agent::client::AgentClient;
+    use crate::{client, server};
+    use crate::server::Session;
+
+    /// Helper to spawn an ssh-agent
+    async fn spawn_agent() -> (
+        tokio::process::Child,
+        std::path::PathBuf,
+        tempfile::TempDir,
+    ) {
+        let dir = tempfile::tempdir().unwrap();
+        let agent_path = dir.path().join("agent");
+        let agent = tokio::process::Command::new("ssh-agent")
+            .arg("-a")
+            .arg(&agent_path)
+            .arg("-D")
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn()
+            .unwrap();
+
+        // Wait for the socket to be created
+        while agent_path.canonicalize().is_err() {
+            tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+        }
+
+        (agent, agent_path, dir)
+    }
+
+    /// Helper to create a test certificate
+    fn create_test_cert(ca_key: &PrivateKey, user_key: &PrivateKey) -> ssh_key::Certificate {
+        use std::time::{SystemTime, UNIX_EPOCH};
+
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        let valid_after = now - 3600;
+        let valid_before = now + 86400 * 365;
+
+        let mut builder = certificate::Builder::new_with_random_nonce(
+            &mut OsRng,
+            user_key.public_key(),
+            valid_after,
+            valid_before,
+        )
+        .unwrap();
+
+        builder.serial(1).unwrap();
+        builder.key_id("test-user-cert").unwrap();
+        builder.cert_type(certificate::CertType::User).unwrap();
+        builder.valid_principal("testuser").unwrap();
+        builder.sign(ca_key).unwrap()
+    }
+
+    #[tokio::test]
+    async fn test_future_certificate_auth_full_flow() {
+        let _ = env_logger::try_init();
+
+        // 1. Spawn ssh-agent
+        let (mut agent, agent_path, dir) = spawn_agent().await;
+
+        // 2. Create CA key and user key
+        let ca_key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap();
+        let user_key = PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap();
+
+        // 3. Create a certificate
+        let cert = create_test_cert(&ca_key, &user_key);
+
+        // 4. Write keys and certificate to temp files and add to agent
+        let user_key_path = dir.path().join("user_key");
+        let cert_path = dir.path().join("user_key-cert.pub");
+
+        let mut f = std::fs::File::create(&user_key_path).unwrap();
+        f.write_all(
+            user_key
+                .to_openssh(ssh_key::LineEnding::LF)
+                .unwrap()
+                .as_bytes(),
+        )
+        .unwrap();
+        std::fs::set_permissions(
+            &user_key_path,
+            std::os::unix::fs::PermissionsExt::from_mode(0o600),
+        )
+        .unwrap();
+
+        let mut f = std::fs::File::create(&cert_path).unwrap();
+        f.write_all(cert.to_openssh().unwrap().as_bytes()).unwrap();
+
+        let status = tokio::process::Command::new("ssh-add")
+            .arg(&user_key_path)
+            .env("SSH_AUTH_SOCK", &agent_path)
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status()
+            .await
+            .unwrap();
+        assert!(status.success(), "ssh-add failed");
+
+        // 5. Set up test server that accepts certificate auth
+        let mut server_config = server::Config::default();
+        server_config.inactivity_timeout = None;
+        server_config.auth_rejection_time = std::time::Duration::from_secs(3);
+        server_config
+            .keys
+            .push(PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap());
+        let server_config = Arc::new(server_config);
+
+        let socket = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = socket.local_addr().unwrap();
+
+        // Server that accepts certificate auth
+        let server_join = tokio::spawn(async move {
+            let (socket, _) = socket.accept().await.unwrap();
+
+            struct CertHandler;
+
+            impl server::Handler for CertHandler {
+                type Error = crate::Error;
+
+                async fn auth_publickey_offered(
+                    &mut self,
+                    _user: &str,
+                    _public_key: &ssh_key::PublicKey,
+                ) -> Result<server::Auth, Self::Error> {
+                    // Accept the key/certificate for the probe
+                    Ok(server::Auth::Accept)
+                }
+
+                async fn auth_openssh_certificate(
+                    &mut self,
+                    _user: &str,
+                    cert: &ssh_key::Certificate,
+                ) -> Result<server::Auth, Self::Error> {
+                    // Validate the certificate is signed by our CA
+                    // In a real server, you'd properly verify the CA signature
+                    // For this test, just check the key_id matches
+                    if cert.key_id() == "test-user-cert" {
+                        Ok(server::Auth::Accept)
+                    } else {
+                        Ok(server::Auth::Reject { proceed_with_methods: None, partial_success: false })
+                    }
+                }
+
+                async fn channel_open_session(
+                    &mut self,
+                    channel: crate::Channel<server::Msg>,
+                    _session: &mut Session,
+                ) -> Result<bool, Self::Error> {
+                    drop(channel);
+                    Ok(true)
+                }
+            }
+
+            let handler = CertHandler;
+            server::run_stream(server_config, socket, handler)
+                .await
+                .unwrap()
+        });
+
+        // 6. Connect as client using FutureCertificate auth with the agent
+        let client_config = Arc::new(client::Config::default());
+
+        struct TestClient;
+        impl client::Handler for TestClient {
+            type Error = crate::Error;
+
+            async fn check_server_key(
+                &mut self,
+                _server_public_key: &ssh_key::PublicKey,
+            ) -> Result<bool, Self::Error> {
+                Ok(true)
+            }
+        }
+
+        let mut session = client::connect(client_config, addr, TestClient)
+            .await
+            .unwrap();
+
+        // Connect to the agent
+        let stream = tokio::net::UnixStream::connect(&agent_path).await.unwrap();
+        let mut agent_client = AgentClient::connect(stream);
+
+        // Authenticate using FutureCertificate (None for hash_alg since Ed25519 doesn't need it)
+        let auth_result = session
+            .authenticate_certificate_with("testuser", cert.clone(), None, &mut agent_client)
+            .await
+            .unwrap();
+
+        // 7. Verify authentication succeeded
+        assert!(auth_result.success(), "Certificate authentication should succeed");
+
+        // Clean up
+        session.disconnect(crate::Disconnect::ByApplication, "", "").await.unwrap();
+        drop(session);
+        server_join.abort();
+        agent.kill().await.unwrap();
+        agent.wait().await.unwrap();
+    }
+}
diff --git a/src/executor/stream_manager.rs b/src/executor/stream_manager.rs
index cc48e0b6..d964b2f0 100644
--- a/src/executor/stream_manager.rs
+++ b/src/executor/stream_manager.rs
@@ -343,7 +343,7 @@ impl Default for MultiNodeStreamManager {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use russh::CryptoVec;
+    use bytes::Bytes;
 
     #[test]
     fn test_node_stream_creation() {
@@ -364,7 +364,7 @@ mod tests {
         let mut stream = NodeStream::new(node, rx);
 
         // Send some output
-        let data = CryptoVec::from(b"test output".to_vec());
+        let data = Bytes::from(b"test output".to_vec());
         tx.send(CommandOutput::StdOut(data)).await.unwrap();
 
         // Poll should receive data
@@ -380,7 +380,7 @@ mod tests {
         let mut stream = NodeStream::new(node, rx);
 
         // Send output
-        let data = CryptoVec::from(b"test".to_vec());
+        let data = Bytes::from(b"test".to_vec());
         tx.send(CommandOutput::StdOut(data)).await.unwrap();
 
         stream.poll();
@@ -431,7 +431,7 @@ mod tests {
         manager.add_stream(node1, rx1);
 
         // Send data
-        let data = CryptoVec::from(b"output1".to_vec());
+        let data = Bytes::from(b"output1".to_vec());
         tx1.send(CommandOutput::StdOut(data)).await.unwrap();
 
         // Poll all should receive data
diff --git a/src/jump/chain/auth.rs b/src/jump/chain/auth.rs
index a12a21e6..66bc5780 100644
--- a/src/jump/chain/auth.rs
+++ b/src/jump/chain/auth.rs
@@ -413,7 +413,7 @@ pub(super) async fn authenticate_connection(
                 let result = handle
                     .authenticate_publickey_with(
                         username,
-                        identity.clone(),
+                        identity.public_key().into_owned(),
                         handle.best_supported_rsa_hash().await?.flatten(),
                         &mut agent,
                     )
diff --git a/src/server/audit/otel.rs b/src/server/audit/otel.rs
index 6085ad01..ecbc15d9 100644
--- a/src/server/audit/otel.rs
+++ b/src/server/audit/otel.rs
@@ -23,16 +23,26 @@ use super::exporter::AuditExporter;
 use anyhow::{Context, Result};
 use async_trait::async_trait;
 use opentelemetry::{
-    logs::{AnyValue, LogRecord, Logger, LoggerProvider as _, Severity},
+    logs::{AnyValue, LogRecord as _, Logger, LoggerProvider as _, Severity},
     KeyValue,
 };
-use opentelemetry_otlp::{ExportConfig, Protocol, WithExportConfig};
-use opentelemetry_sdk::{
-    logs::{Config, LoggerProvider},
-    Resource,
-};
+use opentelemetry_otlp::{LogExporter, WithExportConfig};
+use opentelemetry_sdk::{logs::SdkLoggerProvider, Resource};
 use std::sync::Arc;
 use tokio::sync::RwLock;
+use tokio::sync::RwLockReadGuard;
+
+/// Convert severity to a static string.
+fn severity_to_str(severity: Severity) -> &'static str {
+    match severity {
+        Severity::Trace | Severity::Trace2 | Severity::Trace3 | Severity::Trace4 => "TRACE",
+        Severity::Debug | Severity::Debug2 | Severity::Debug3 | Severity::Debug4 => "DEBUG",
+        Severity::Info | Severity::Info2 | Severity::Info3 | Severity::Info4 => "INFO",
+        Severity::Warn | Severity::Warn2 | Severity::Warn3 | Severity::Warn4 => "WARN",
+        Severity::Error | Severity::Error2 | Severity::Error3 | Severity::Error4 => "ERROR",
+        Severity::Fatal | Severity::Fatal2 | Severity::Fatal3 | Severity::Fatal4 => "FATAL",
+    }
+}
 
 /// OpenTelemetry audit exporter.
 ///
@@ -61,7 +71,7 @@ use tokio::sync::RwLock;
 /// # }
 /// ```
 pub struct OtelExporter {
-    logger_provider: Arc<RwLock<LoggerProvider>>,
+    logger_provider: Arc<RwLock<SdkLoggerProvider>>,
     endpoint: String,
 }
 
@@ -97,25 +107,20 @@ impl OtelExporter {
                  Use HTTPS for production deployments."
             );
         }
-        let export_config = ExportConfig {
-            endpoint: endpoint.to_string(),
-            protocol: Protocol::Grpc,
-            ..Default::default()
-        };
-
-        let exporter = opentelemetry_otlp::new_exporter()
-            .tonic()
-            .with_export_config(export_config)
-            .build_log_exporter()
+
+        let exporter = LogExporter::builder()
+            .with_tonic()
+            .with_endpoint(endpoint)
+            .build()
             .context("failed to build OTLP log exporter")?;
 
-        let resource = Resource::new(vec![
-            KeyValue::new("service.name", "bssh-server"),
-            KeyValue::new("service.version", env!("CARGO_PKG_VERSION")),
-        ]);
+        let resource = Resource::builder()
+            .with_service_name("bssh-server")
+            .with_attribute(KeyValue::new("service.version", env!("CARGO_PKG_VERSION")))
+            .build();
 
-        let logger_provider = LoggerProvider::builder()
-            .with_config(Config::default().with_resource(resource))
+        let logger_provider = SdkLoggerProvider::builder()
+            .with_resource(resource)
             .with_simple_exporter(exporter)
             .build();
 
@@ -125,57 +130,66 @@ impl OtelExporter {
         })
     }
 
-    /// Convert an audit event to an OpenTelemetry log record.
-    fn event_to_log_record(&self, event: &AuditEvent) -> LogRecord {
-        let mut attributes = vec![
-            KeyValue::new("event.id", event.id.clone()),
-            KeyValue::new("event.type", format!("{:?}", event.event_type)),
-            KeyValue::new("session.id", event.session_id.clone()),
-            KeyValue::new("user.name", event.user.clone()),
-            KeyValue::new("result", format!("{:?}", event.result)),
-        ];
+    /// Emit an audit event as an OpenTelemetry log record.
+    fn emit_event(&self, provider: &SdkLoggerProvider, event: &AuditEvent) {
+        let logger = provider.logger("bssh-audit");
+        let mut record = logger.create_log_record();
+
+        let severity = self.event_to_severity(&event.event_type, &event.result);
+        let body = format!(
+            "{:?} - {} - {:?}",
+            event.event_type, event.user, event.result
+        );
 
+        record.set_timestamp(event.timestamp.into());
+        record.set_observed_timestamp(std::time::SystemTime::now());
+        record.set_severity_number(severity);
+        record.set_severity_text(severity_to_str(severity));
+        record.set_body(AnyValue::String(body.into()));
+
+        // Add core attributes
+        record.add_attribute("event.id", AnyValue::String(event.id.clone().into()));
+        record.add_attribute(
+            "event.type",
+            AnyValue::String(format!("{:?}", event.event_type).into()),
+        );
+        record.add_attribute(
+            "session.id",
+            AnyValue::String(event.session_id.clone().into()),
+        );
+        record.add_attribute("user.name", AnyValue::String(event.user.clone().into()));
+        record.add_attribute(
+            "result",
+            AnyValue::String(format!("{:?}", event.result).into()),
+        );
+
+        // Add optional attributes
         if let Some(ref ip) = event.client_ip {
-            attributes.push(KeyValue::new("client.ip", ip.to_string()));
+            record.add_attribute("client.ip", AnyValue::String(ip.to_string().into()));
         }
         if let Some(ref path) = event.path {
-            attributes.push(KeyValue::new("file.path", path.display().to_string()));
+            record.add_attribute(
+                "file.path",
+                AnyValue::String(path.display().to_string().into()),
+            );
         }
         if let Some(ref dest_path) = event.dest_path {
-            attributes.push(KeyValue::new(
+            record.add_attribute(
                 "file.dest_path",
-                dest_path.display().to_string(),
-            ));
+                AnyValue::String(dest_path.display().to_string().into()),
+            );
         }
         if let Some(bytes) = event.bytes {
-            attributes.push(KeyValue::new("file.bytes", bytes as i64));
+            record.add_attribute("file.bytes", AnyValue::Int(bytes as i64));
         }
         if let Some(ref protocol) = event.protocol {
-            attributes.push(KeyValue::new("protocol", protocol.clone()));
+            record.add_attribute("protocol", AnyValue::String(protocol.clone().into()));
         }
         if let Some(ref details) = event.details {
-            attributes.push(KeyValue::new("details", details.clone()));
+            record.add_attribute("details", AnyValue::String(details.clone().into()));
         }
 
-        let severity = self.event_to_severity(&event.event_type, &event.result);
-        let body = format!(
-            "{:?} - {} - {:?}",
-            event.event_type, event.user, event.result
-        );
-
-        LogRecord::builder()
-            .with_timestamp(event.timestamp.into())
-            .with_observed_timestamp(event.timestamp.into())
-            .with_severity_number(severity)
-            .with_severity_text(format!("{:?}", severity))
-            .with_body(body.into())
-            .with_attributes(
-                attributes
-                    .into_iter()
-                    .map(|kv| (kv.key, AnyValue::from(kv.value)))
-                    .collect(),
-            )
-            .build()
+        logger.emit(record);
     }
 
     /// Map event type and result to OpenTelemetry severity level.
@@ -228,48 +242,33 @@ impl OtelExporter {
 #[async_trait]
 impl AuditExporter for OtelExporter {
     async fn export(&self, event: AuditEvent) -> Result<()> {
-        let log_record = self.event_to_log_record(&event);
         let provider = self.logger_provider.read().await;
-        let logger = provider.logger("bssh-audit");
-
-        logger.emit(log_record);
-
+        self.emit_event(&provider, &event);
         Ok(())
     }
 
     async fn export_batch(&self, events: &[AuditEvent]) -> Result<()> {
         let provider = self.logger_provider.read().await;
-        let logger = provider.logger("bssh-audit");
-
         for event in events {
-            let log_record = self.event_to_log_record(event);
-            logger.emit(log_record);
+            self.emit_event(&provider, event);
         }
-
         Ok(())
     }
 
     async fn flush(&self) -> Result<()> {
-        let provider = self.logger_provider.read().await;
-        let results = provider.force_flush();
-
-        // Check if any flush operation failed
-        for result in results {
-            result.context("failed to flush OTLP log exporter")?;
-        }
-
+        let provider: RwLockReadGuard<'_, SdkLoggerProvider> = self.logger_provider.read().await;
+        provider
+            .force_flush()
+            .context("failed to flush OTLP log exporter")?;
         Ok(())
     }
 
     async fn close(&self) -> Result<()> {
-        let mut provider = self.logger_provider.write().await;
-        let results = provider.shutdown();
-
-        // Check if any shutdown operation failed
-        for result in results {
-            result.context("failed to shutdown OTLP log exporter")?;
-        }
-
+        let provider: tokio::sync::RwLockWriteGuard<'_, SdkLoggerProvider> =
+            self.logger_provider.write().await;
+        provider
+            .shutdown()
+            .context("failed to shutdown OTLP log exporter")?;
         Ok(())
     }
 }
@@ -285,8 +284,6 @@ impl std::fmt::Debug for OtelExporter {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::net::IpAddr;
-    use std::path::PathBuf;
 
     #[tokio::test]
     async fn test_event_to_severity_security_events() {
@@ -329,76 +326,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_event_to_log_record_basic() {
-        let exporter = OtelExporter::new("http://localhost:4317").unwrap();
-        let event = AuditEvent::new(
-            EventType::AuthSuccess,
-            "alice".to_string(),
-            "session-123".to_string(),
-        );
-
-        let log_record = exporter.event_to_log_record(&event);
-
-        assert!(log_record.timestamp.is_some());
-        assert_eq!(log_record.severity_number, Some(Severity::Info));
-        assert!(log_record.body.is_some());
-        assert!(log_record.attributes.is_some());
-
-        let attributes = log_record.attributes.unwrap();
-        assert!(attributes.iter().any(|kv| kv.0.as_str() == "event.id"));
-        assert!(attributes.iter().any(|kv| {
-            if kv.0.as_str() == "user.name" {
-                matches!(&kv.1, AnyValue::String(s) if s.as_ref() == "alice")
-            } else {
-                false
-            }
-        }));
-    }
-
-    #[tokio::test]
-    async fn test_event_to_log_record_with_all_fields() {
-        let exporter = OtelExporter::new("http://localhost:4317").unwrap();
-        let ip: IpAddr = "192.168.1.100".parse().unwrap();
-        let event = AuditEvent::new(
-            EventType::FileUploaded,
-            "bob".to_string(),
-            "session-456".to_string(),
-        )
-        .with_client_ip(ip)
-        .with_path(PathBuf::from("/home/bob/file.txt"))
-        .with_bytes(1024)
-        .with_protocol("sftp")
-        .with_details("Upload completed".to_string());
-
-        let log_record = exporter.event_to_log_record(&event);
-        let attributes = log_record.attributes.unwrap();
-
-        assert!(attributes.iter().any(|kv| kv.0.as_str() == "client.ip"));
-        assert!(attributes.iter().any(|kv| kv.0.as_str() == "file.path"));
-        assert!(attributes.iter().any(|kv| {
-            if kv.0.as_str() == "file.bytes" {
-                matches!(&kv.1, AnyValue::Int(1024))
-            } else {
-                false
-            }
-        }));
-        assert!(attributes.iter().any(|kv| {
-            if kv.0.as_str() == "protocol" {
-                matches!(&kv.1, AnyValue::String(s) if s.as_ref() == "sftp")
-            } else {
-                false
-            }
-        }));
-        assert!(attributes.iter().any(|kv| {
-            if kv.0.as_str() == "details" {
-                matches!(&kv.1, AnyValue::String(s) if s.as_ref() == "Upload completed")
-            } else {
-                false
-            }
-        }));
-    }
-
-    #[tokio::test]
+    #[ignore = "Requires running OTLP collector; SimpleLogProcessor blocks on gRPC send"]
     async fn test_export_single_event() {
         let exporter = OtelExporter::new("http://localhost:4317").unwrap();
         let event = AuditEvent::new(
@@ -413,6 +341,7 @@ mod tests {
     }
 
     #[tokio::test]
+    #[ignore = "Requires running OTLP collector; SimpleLogProcessor blocks on gRPC send"]
     async fn test_export_batch() {
         let exporter = OtelExporter::new("http://localhost:4317").unwrap();
         let events = vec![
diff --git a/src/server/exec.rs b/src/server/exec.rs
index 922aa680..4d771424 100644
--- a/src/server/exec.rs
+++ b/src/server/exec.rs
@@ -56,7 +56,7 @@ use std::time::Duration;
 use anyhow::{Context, Result};
 use regex::Regex;
 use russh::server::Handle;
-use russh::{ChannelId, CryptoVec};
+use russh::ChannelId;
 use serde::{Deserialize, Serialize};
 use tokio::io::AsyncReadExt;
 use tokio::process::Command;
@@ -268,7 +268,11 @@ impl CommandExecutor {
             // Send error message to stderr
             let error_msg = format!("Command rejected: {e}\n");
             let _ = handle
-                .extended_data(channel_id, 1, CryptoVec::from_slice(error_msg.as_bytes()))
+                .extended_data(
+                    channel_id,
+                    1,
+                    bytes::Bytes::copy_from_slice(error_msg.as_bytes()),
+                )
                 .await;
             return Ok(EXIT_CODE_REJECTED);
         }
@@ -386,7 +390,11 @@ impl CommandExecutor {
                         self.config.timeout_secs
                     );
                     let _ = handle
-                        .extended_data(channel_id, 1, CryptoVec::from_slice(timeout_msg.as_bytes()))
+                        .extended_data(
+                            channel_id,
+                            1,
+                            bytes::Bytes::copy_from_slice(timeout_msg.as_bytes()),
+                        )
                         .await;
                     return Ok(EXIT_CODE_TIMEOUT);
                 }
@@ -424,7 +432,7 @@ impl CommandExecutor {
                 break;
             }
 
-            let data = CryptoVec::from_slice(&buffer[..n]);
+            let data = bytes::Bytes::copy_from_slice(&buffer[..n]);
 
             let result = if is_stderr {
                 // Extended data type 1 = stderr
diff --git a/src/server/scp.rs b/src/server/scp.rs
index 1fdec39d..cf71476d 100644
--- a/src/server/scp.rs
+++ b/src/server/scp.rs
@@ -50,7 +50,7 @@ use std::path::{Component, Path, PathBuf};
 
 use anyhow::{Context, Result};
 use russh::server::Handle;
-use russh::{ChannelId, CryptoVec};
+use russh::ChannelId;
 use tokio::fs::{self, File, OpenOptions};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::sync::mpsc;
@@ -1007,7 +1007,7 @@ impl ScpHandler {
     /// Send data to the channel.
     async fn send_data(&self, channel_id: ChannelId, handle: &Handle, data: &[u8]) -> Result<()> {
         handle
-            .data(channel_id, CryptoVec::from_slice(data))
+            .data(channel_id, bytes::Bytes::copy_from_slice(data))
             .await
             .map_err(|_| anyhow::anyhow!("Failed to send data"))?;
         Ok(())
diff --git a/src/server/shell.rs b/src/server/shell.rs
index 149d5f81..d8877b99 100644
--- a/src/server/shell.rs
+++ b/src/server/shell.rs
@@ -38,7 +38,7 @@ use std::sync::Arc;
 
 use anyhow::{Context, Result};
 use russh::server::{Handle, Msg};
-use russh::{ChannelId, ChannelStream, CryptoVec};
+use russh::{ChannelId, ChannelStream};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::process::Child;
 use tokio::sync::{mpsc, RwLock};
@@ -522,7 +522,7 @@ pub async fn run_shell_io_loop_with_handle(
                         }
                         Ok(Ok(n)) => {
                             tracing::trace!(channel = ?channel_id, bytes = n, "Read from PTY, calling handle.data()");
-                            let data = CryptoVec::from_slice(&buf[..n]);
+                            let data = bytes::Bytes::copy_from_slice(&buf[..n]);
                             match handle_clone.data(channel_id, data).await {
                                 Ok(_) => {
                                     tracing::trace!(channel = ?channel_id, "handle.data() returned successfully");
diff --git a/src/ssh/tokio_client/authentication.rs b/src/ssh/tokio_client/authentication.rs
index c0a72367..a60a5ece 100644
--- a/src/ssh/tokio_client/authentication.rs
+++ b/src/ssh/tokio_client/authentication.rs
@@ -274,19 +274,19 @@ pub(super) async fn authenticate<H: Handler>(
             let mut agent = russh::keys::agent::client::AgentClient::connect_env()
                 .await
                 .unwrap();
-            let mut auth_identity: Option<russh::keys::PublicKey> = None;
+            let mut auth_identity_found = false;
             for identity in agent
                 .request_identities()
                 .await
                 .map_err(super::Error::KeyInvalid)?
             {
-                if identity == cpubk {
-                    auth_identity = Some(identity.clone());
+                if *identity.public_key() == cpubk {
+                    auth_identity_found = true;
                     break;
                 }
             }
 
-            if auth_identity.is_none() {
+            if !auth_identity_found {
                 return Err(super::Error::KeyAuthFailed);
             }
 
@@ -322,7 +322,7 @@ pub(super) async fn authenticate<H: Handler>(
                 let result = handle
                     .authenticate_publickey_with(
                         username,
-                        identity.clone(),
+                        identity.public_key().into_owned(),
                         handle.best_supported_rsa_hash().await?.flatten(),
                         &mut agent,
                     )
diff --git a/src/ssh/tokio_client/channel_manager.rs b/src/ssh/tokio_client/channel_manager.rs
index be17a4e7..dfa472d5 100644
--- a/src/ssh/tokio_client/channel_manager.rs
+++ b/src/ssh/tokio_client/channel_manager.rs
@@ -20,9 +20,9 @@
 //! - Managing interactive shells and PTY sessions
 //! - Port forwarding channels
 
+use bytes::Bytes;
 use russh::client::Msg;
 use russh::Channel;
-use russh::CryptoVec;
 use std::io;
 use std::net::SocketAddr;
 use tokio::sync::mpsc::{channel, Receiver, Sender};
@@ -66,9 +66,9 @@ const MAX_SUDO_PASSWORD_SENDS: u32 = 10;
 #[derive(Debug, Clone)]
 pub enum CommandOutput {
     /// Standard output data
-    StdOut(CryptoVec),
+    StdOut(Bytes),
     /// Standard error data
-    StdErr(CryptoVec),
+    StdErr(Bytes),
     /// Exit code (sent when command completes)
     ExitCode(u32),
 }
@@ -436,7 +436,7 @@ impl Client {
                             password_send_count
                         );
                         let _ = sender
-                            .send(CommandOutput::StdErr(CryptoVec::from(error_msg.as_bytes())))
+                            .send(CommandOutput::StdErr(Bytes::from(error_msg.into_bytes())))
                             .await;
                         // Send exit code 1 to indicate failure to the stream
                         let _ = sender.send(CommandOutput::ExitCode(1)).await;
@@ -512,7 +512,7 @@ impl Client {
                                 password_send_count
                             );
                             let _ = sender
-                                .send(CommandOutput::StdErr(CryptoVec::from(error_msg.as_bytes())))
+                                .send(CommandOutput::StdErr(Bytes::from(error_msg.into_bytes())))
                                 .await;
                             // Send exit code 1 to indicate failure to the stream
                             let _ = sender.send(CommandOutput::ExitCode(1)).await;
diff --git a/tests/streaming_integration_tests.rs b/tests/streaming_integration_tests.rs
index 1c87eb47..fccceb4f 100644
--- a/tests/streaming_integration_tests.rs
+++ b/tests/streaming_integration_tests.rs
@@ -24,7 +24,7 @@
 use bssh::executor::{ExecutionStatus, MultiNodeStreamManager, NodeStream};
 use bssh::node::Node;
 use bssh::ssh::tokio_client::CommandOutput;
-use russh::CryptoVec;
+use bytes::Bytes;
 use tokio::sync::mpsc;
 
 // ============================================================================
@@ -55,7 +55,7 @@ async fn test_node_stream_receives_stdout() {
     let mut stream = NodeStream::new(node, rx);
 
     // Send stdout data
-    let data = CryptoVec::from(b"Hello, World!".to_vec());
+    let data = Bytes::from(b"Hello, World!".to_vec());
     tx.send(CommandOutput::StdOut(data)).await.unwrap();
 
     // Poll should receive data
@@ -75,7 +75,7 @@ async fn test_node_stream_receives_stderr() {
     let mut stream = NodeStream::new(node, rx);
 
     // Send stderr data
-    let data = CryptoVec::from(b"Error: something went wrong".to_vec());
+    let data = Bytes::from(b"Error: something went wrong".to_vec());
     tx.send(CommandOutput::StdErr(data)).await.unwrap();
 
     stream.poll();
@@ -90,8 +90,8 @@ async fn test_node_stream_stdout_stderr_separation() {
     let mut stream = NodeStream::new(node, rx);
 
     // Send both stdout and stderr
-    let stdout_data = CryptoVec::from(b"stdout output".to_vec());
-    let stderr_data = CryptoVec::from(b"stderr output".to_vec());
+    let stdout_data = Bytes::from(b"stdout output".to_vec());
+    let stderr_data = Bytes::from(b"stderr output".to_vec());
     tx.send(CommandOutput::StdOut(stdout_data)).await.unwrap();
     tx.send(CommandOutput::StdErr(stderr_data)).await.unwrap();
 
@@ -108,7 +108,7 @@ async fn test_node_stream_multiple_chunks() {
 
     // Send multiple chunks
     for i in 1..=5 {
-        let data = CryptoVec::from(format!("chunk{i}").into_bytes());
+        let data = Bytes::from(format!("chunk{i}").into_bytes());
         tx.send(CommandOutput::StdOut(data)).await.unwrap();
     }
 
@@ -160,8 +160,8 @@ async fn test_node_stream_take_buffers() {
     let mut stream = NodeStream::new(node, rx);
 
     // Send data
-    let stdout = CryptoVec::from(b"stdout data".to_vec());
-    let stderr = CryptoVec::from(b"stderr data".to_vec());
+    let stdout = Bytes::from(b"stdout data".to_vec());
+    let stderr = Bytes::from(b"stderr data".to_vec());
     tx.send(CommandOutput::StdOut(stdout)).await.unwrap();
     tx.send(CommandOutput::StdErr(stderr)).await.unwrap();
 
@@ -244,8 +244,8 @@ async fn test_manager_poll_all() {
     manager.add_stream(node2, rx2);
 
     // Send data to both streams
-    let data1 = CryptoVec::from(b"output1".to_vec());
-    let data2 = CryptoVec::from(b"output2".to_vec());
+    let data1 = Bytes::from(b"output1".to_vec());
+    let data2 = Bytes::from(b"output2".to_vec());
     tx1.send(CommandOutput::StdOut(data1)).await.unwrap();
     tx2.send(CommandOutput::StdOut(data2)).await.unwrap();
 
@@ -354,9 +354,9 @@ async fn test_partial_output_accumulation() {
     let mut stream = NodeStream::new(node, rx);
 
     // Simulate partial line output
-    let chunk1 = CryptoVec::from(b"partial ".to_vec());
-    let chunk2 = CryptoVec::from(b"line ".to_vec());
-    let chunk3 = CryptoVec::from(b"complete\n".to_vec());
+    let chunk1 = Bytes::from(b"partial ".to_vec());
+    let chunk2 = Bytes::from(b"line ".to_vec());
+    let chunk3 = Bytes::from(b"complete\n".to_vec());
 
     tx.send(CommandOutput::StdOut(chunk1)).await.unwrap();
     stream.poll();
@@ -378,16 +378,16 @@ async fn test_interleaved_stdout_stderr() {
     let mut stream = NodeStream::new(node, rx);
 
     // Send interleaved stdout and stderr
-    tx.send(CommandOutput::StdOut(CryptoVec::from(b"out1".to_vec())))
+    tx.send(CommandOutput::StdOut(Bytes::from(b"out1".to_vec())))
         .await
         .unwrap();
-    tx.send(CommandOutput::StdErr(CryptoVec::from(b"err1".to_vec())))
+    tx.send(CommandOutput::StdErr(Bytes::from(b"err1".to_vec())))
         .await
         .unwrap();
-    tx.send(CommandOutput::StdOut(CryptoVec::from(b"out2".to_vec())))
+    tx.send(CommandOutput::StdOut(Bytes::from(b"out2".to_vec())))
         .await
         .unwrap();
-    tx.send(CommandOutput::StdErr(CryptoVec::from(b"err2".to_vec())))
+    tx.send(CommandOutput::StdErr(Bytes::from(b"err2".to_vec())))
         .await
         .unwrap();
 
@@ -446,7 +446,7 @@ async fn test_manager_mixed_connection_states() {
     let node1 = Node::new("host1".to_string(), 22, "user".to_string());
     let (tx1, rx1) = mpsc::channel::<CommandOutput>(100);
     manager.add_stream(node1, rx1);
-    tx1.send(CommandOutput::StdOut(CryptoVec::from(b"success".to_vec())))
+    tx1.send(CommandOutput::StdOut(Bytes::from(b"success".to_vec())))
         .await
         .unwrap();
     tx1.send(CommandOutput::ExitCode(0)).await.unwrap();
@@ -462,7 +462,7 @@ async fn test_manager_mixed_connection_states() {
     let node3 = Node::new("host3".to_string(), 22, "user".to_string());
     let (tx3, rx3) = mpsc::channel::<CommandOutput>(100);
     manager.add_stream(node3, rx3);
-    tx3.send(CommandOutput::StdOut(CryptoVec::from(b"partial".to_vec())))
+    tx3.send(CommandOutput::StdOut(Bytes::from(b"partial".to_vec())))
         .await
         .unwrap();
     tx3.send(CommandOutput::ExitCode(1)).await.unwrap();
@@ -487,7 +487,7 @@ async fn test_high_throughput_single_stream() {
     let mut stream = NodeStream::new(node, rx);
 
     // Send many small chunks
-    let chunk = CryptoVec::from(vec![b'x'; 100]);
+    let chunk = Bytes::from(vec![b'x'; 100]);
     for _ in 0..1000 {
         tx.send(CommandOutput::StdOut(chunk.clone())).await.unwrap();
     }
@@ -519,7 +519,7 @@ async fn test_many_concurrent_streams() {
 
     // Send data to all streams
     for (i, tx) in senders.iter().enumerate() {
-        let data = CryptoVec::from(format!("output from node {i}").into_bytes());
+        let data = Bytes::from(format!("output from node {i}").into_bytes());
         tx.send(CommandOutput::StdOut(data)).await.unwrap();
     }
 
@@ -558,7 +558,7 @@ async fn test_manager_poll_all_returns_correctly() {
     assert!(!manager.poll_all(), "Should return false when no data");
 
     // Send data
-    let data = CryptoVec::from(b"data".to_vec());
+    let data = Bytes::from(b"data".to_vec());
     tx.send(CommandOutput::StdOut(data)).await.unwrap();
 
     assert!(manager.poll_all(), "Should return true when data received");
@@ -575,7 +575,7 @@ async fn test_stream_with_unicode_output() {
     let mut stream = NodeStream::new(node, rx);
 
     // Send unicode data with actual Korean, Chinese, and Emoji characters
-    let data = CryptoVec::from(
+    let data = Bytes::from(
         "Hello, World! Korean: 안녕 Chinese: 你好 Emoji: 🚀🎉"
             .as_bytes()
             .to_vec(),
@@ -601,7 +601,7 @@ async fn test_stream_with_binary_output() {
 
     // Send binary data with null bytes
     let binary_data: Vec<u8> = vec![0x00, 0x01, 0x02, 0xFF, 0xFE, 0x00];
-    let data = CryptoVec::from(binary_data.clone());
+    let data = Bytes::from(binary_data.clone());
     tx.send(CommandOutput::StdOut(data)).await.unwrap();
 
     stream.poll();
@@ -632,7 +632,7 @@ async fn test_app_data_change_detection() {
     assert!(!changed, "Should not detect change when data is same");
 
     // Send data
-    let data = CryptoVec::from(b"new output".to_vec());
+    let data = Bytes::from(b"new output".to_vec());
     tx.send(CommandOutput::StdOut(data)).await.unwrap();
     manager.poll_all();
 

From ebb4f508c86cb1d6f7f2225a34cd19509ad73c55 Mon Sep 17 00:00:00 2001
From: Jeongkyu Shin <inureyes@gmail.com>
Date: Fri, 3 Apr 2026 14:36:23 +0900
Subject: [PATCH 2/2] fix: Add #[serial] to env var tests to prevent race
 conditions in CI

---
 tests/pdsh_compat_test.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/pdsh_compat_test.rs b/tests/pdsh_compat_test.rs
index 8b51ef8d..ca70d36c 100644
--- a/tests/pdsh_compat_test.rs
+++ b/tests/pdsh_compat_test.rs
@@ -18,6 +18,7 @@
 //! and behaves as expected in pdsh compatibility mode.
 
 use bssh::cli::{has_pdsh_compat_flag, remove_pdsh_compat_flag, PdshCli, PDSH_COMPAT_ENV_VAR};
+use serial_test::serial;
 use std::env;
 
 /// Helper to run a test with env var protection
@@ -116,6 +117,7 @@ fn test_remove_pdsh_compat_flag_no_flag_present() {
 // =============================================================================
 
 #[test]
+#[serial]
 fn test_env_var_detection_with_one() {
     without_env_var(PDSH_COMPAT_ENV_VAR, || {
         with_env_var(PDSH_COMPAT_ENV_VAR, "1", || {
@@ -130,6 +132,7 @@ fn test_env_var_detection_with_one() {
 }
 
 #[test]
+#[serial]
 fn test_env_var_detection_with_true() {
     without_env_var(PDSH_COMPAT_ENV_VAR, || {
         with_env_var(PDSH_COMPAT_ENV_VAR, "true", || {
@@ -141,6 +144,7 @@ fn test_env_var_detection_with_true() {
 }
 
 #[test]
+#[serial]
 fn test_env_var_detection_disabled_with_zero() {
     without_env_var(PDSH_COMPAT_ENV_VAR, || {
         with_env_var(PDSH_COMPAT_ENV_VAR, "0", || {
@@ -154,6 +158,7 @@ fn test_env_var_detection_disabled_with_zero() {
 }
 
 #[test]
+#[serial]
 fn test_env_var_detection_disabled_with_false() {
     without_env_var(PDSH_COMPAT_ENV_VAR, || {
         with_env_var(PDSH_COMPAT_ENV_VAR, "false", || {