net-ssh 7.3.3 → 8.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d9097275f7c3c0123783d9c29f8c4c4bfe3a3c8d68410357078e91859950f3f
-  data.tar.gz: b5a1013faa8b1cfbe5645e849329c99b62db9d944894287747a12c33f5356d9a
+  metadata.gz: ee72c6673cb55fe69cdb90bc49d0b7266b29cb80f7a14794f873e048075cde2b
+  data.tar.gz: b9416f51d2b80d5d0bbbcac1b33a4272d5b5add59d81421ca8eaa84db2fd0823
 SHA512:
-  metadata.gz: 04ceefc617349311ddceebb606aa003dec8c6aa671363a13f939486d1bdfa5b55c49a56096651d8667f30f57ea109728e3cdae1f25545aa3c1c892b1db2948bf
-  data.tar.gz: 3a9f23ad8a0843628f5dc500c83ceabca815756f925fbddc9725a12e0e19a9eeacf42f26f924b9c038edf8e95f832720c2297b0d0c8fdfcd6844f94d72f834b9
+  metadata.gz: 4f1d529b4af06145b892c6ece94d2fcc6a9d2b65b93db633189b71988b8bc03aa64feffdfce3509ce64809378ff542b04f01381419d5a9e11246c7303d258583
+  data.tar.gz: 2170524d2a24e1ec8d0c07c3237d140ad00c412c59875f6f178b6f4a2c47ce9d16f8418dee56e0425d8ec8a214f50e0cc96e434d1b6e37998125e1cda9ebb41e

data/.github/workflows/ci-with-docker.yml

@@ -17,9 +17,6 @@ jobs:
     - name: Build docker images
       run: docker compose build
 
-    - name: Run ruby 2.6
-      run: docker compose run ruby-2.6
-
     - name: Run ruby 2.7
       run: docker compose run ruby-2.7
 

data/.github/workflows/ci.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-22.04
     strategy:
       matrix:
-        ruby-version: [2.6.10, 2.7.7, 3.0.6, 3.1.3, 3.2.1, 3.3.0, 3.4]
+        ruby-version: [2.7.8, 3.0.6, 3.1.3, 3.2.1, 3.3.0, 3.4]
     steps:
       - uses: actions/checkout@v3
 
@@ -39,11 +39,10 @@ jobs:
             ${{ runner.os }}-pip-v1
       - name: Bundle install
         run: |
-          gem install bundler ${{ (startsWith(matrix.ruby-version, '2.6.') || startsWith(matrix.ruby-version, '2.7.')) && '-v 2.4.22' || '' }}
+          gem install bundler ${{ startsWith(matrix.ruby-version, '2.7.') && '-v 2.4.22' || '' }}
           bundle config set path 'vendor/bundle'
           bundle config set --local path 'vendor/bundle'
           bundle install --jobs 4 --retry 3
-          BUNDLE_GEMFILE=./Gemfile.noed25519 bundle install --jobs 4 --retry 3
         env:
           BUNDLE_PATH: vendor/bundle
 
@@ -79,20 +78,6 @@ jobs:
           NET_SSH_RUN_INTEGRATION_TESTS: 1
           CI: 1
           RUBYOPT: '--enable=frozen-string-literal'
-      - name: Run tests (without rbnacl)
-        run: bundle exec rake test
-        env:
-          BUNDLE_GEMFILE: ./Gemfile.norbnacl
-          NET_SSH_RUN_INTEGRATION_TESTS: 1
-          CI: 1
-          RUBYOPT: '--enable=frozen-string-literal'
-      - name: Run Tests (without ed25519)
-        run: bundle exec rake test
-        env:
-          BUNDLE_GEMFILE: ./Gemfile.noed25519
-          NET_SSH_RUN_INTEGRATION_TESTS: 1
-          CI: 1
-          RUBYOPT: '--enable=frozen-string-literal'
       - name: Run test helper test
         run: bundle exec rake test_test
         env:

data/.rubocop.yml

@@ -4,7 +4,7 @@ AllCops:
     - "vendor/**/.*"
     - "vendor/**/*"
   NewCops: enable
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 2.7
 
 inherit_from: .rubocop_todo.yml
 

data/.rubocop_todo.yml

@@ -335,6 +335,7 @@ Naming/MemoizedInstanceVariableName:
 Naming/MethodName:
   Exclude:
     - 'lib/net/ssh/authentication/ed25519_loader.rb'
+    - 'lib/net/ssh/transport/chacha20_poly1305_cipher_loader.rb'
     - 'lib/net/ssh/transport/kex/curve25519_sha256_loader.rb'
     - 'test/authentication/test_agent.rb'
     - 'test/authentication/test_session.rb'
@@ -758,10 +759,12 @@ Style/OpenStructUse:
   Exclude:
     - 'test/authentication/test_ed25519.rb'
     - 'test/common.rb'
+    - 'test/test_known_hosts.rb'
     - 'test/transport/kex/test_curve25519_sha256.rb'
     - 'test/transport/kex/test_diffie_hellman_group1_sha1.rb'
     - 'test/transport/kex/test_ecdh_sha2_nistp256.rb'
     - 'test/verifiers/test_always.rb'
+    - 'test/verifiers/test_cert_authority_checks.rb'
 
 # Offense count: 16
 # Configuration parameters: AllowedMethods.

data/CHANGES.txt

@@ -1,3 +1,7 @@
+=== 8.0.0 beta3
+
+  * Verify @cert-authority host certificate constraints — principals (shell-glob, matching OpenSSH), validity window, host type, and critical options — instead of trusting any CA-signed certificate for any host [#1009]
+
 === 7.3.3
 
   * Support .pub file as IdentityFile to filter/prioritize agent keys (1Password SSH agent use case) [#942]

data/Dockerfile

@@ -26,4 +26,4 @@ RUN gem install bundler ${BUNDLERV}  && bundle install
 
 COPY . $INSTALL_PATH/
 
-CMD service ssh start && rake test && NET_SSH_NO_ED25519=1 rake test
+CMD service ssh start && rake test

data/Dockerfile.openssl3

@@ -2,7 +2,7 @@ FROM ubuntu:22.04
 
 ENV INSTALL_PATH="/netssh"
 
-RUN apt update && apt install -y openssl ruby ruby-dev git build-essential
+RUN apt update && apt install -y openssl libssl-dev ruby ruby-dev git build-essential
 
 WORKDIR $INSTALL_PATH
 

data/Dockerfile.zlib_ng

@@ -11,7 +11,7 @@ ENV INSTALL_PATH="/netssh"
 # Ruby/OpenSSL initialises — setting it in the Rakefile is too late.
 ENV OPENSSL_CONF="/netssh/test/openssl3.conf"
 
-RUN dnf install -y openssl ruby ruby-devel git make gcc zlib-ng crypto-policies-scripts && \
+RUN dnf install -y openssl openssl-devel ruby ruby-devel git make gcc zlib-ng crypto-policies-scripts && \
     update-crypto-policies --set LEGACY
 
 WORKDIR $INSTALL_PATH

data/README.md

@@ -40,7 +40,7 @@ Unsecure algoritms will definitely be removed in Net::SSH 8.*.
 | Name                 | Support               | Details  |
 |----------------------|-----------------------|----------|
 | ssh-rsa              | OK                    |          |
-| ssh-ed25519          | OK                    | Require the gem `ed25519` |
+| ssh-ed25519          | OK                    | Backed by Ruby OpenSSL raw Ed25519 APIs (`openssl >= 3.2.0`) |
 | ecdsa-sha2-nistp521  | OK                    | [using weak elliptic curves](https://safecurves.cr.yp.to/) |
 | ecdsa-sha2-nistp384  | OK                    | [using weak elliptic curves](https://safecurves.cr.yp.to/) |
 | ecdsa-sha2-nistp256  | OK                    | [using weak elliptic curves](https://safecurves.cr.yp.to/) |
@@ -50,7 +50,7 @@ Unsecure algoritms will definitely be removed in Net::SSH 8.*.
 
 | Name                                 | Support               | Details  |
 |--------------------------------------|-----------------------|----------|
-| curve25519-sha256                    | OK                    | Require the gem `x25519` |
+| curve25519-sha256                    | OK                    | Backed by Ruby OpenSSL raw X25519 APIs (`openssl >= 3.2.0`) |
 | ecdh-sha2-nistp521                   | OK                    | [using weak elliptic curves](https://safecurves.cr.yp.to/) |
 | ecdh-sha2-nistp384                   | OK                    | [using weak elliptic curves](https://safecurves.cr.yp.to/) |
 | ecdh-sha2-nistp256                   | OK                    | [using weak elliptic curves](https://safecurves.cr.yp.to/) |
@@ -64,7 +64,7 @@ Unsecure algoritms will definitely be removed in Net::SSH 8.*.
 | Name                                 | Support               | Details  |
 |--------------------------------------|-----------------------|----------|
 | aes256-ctr / aes192-ctr / aes128-ctr | OK                    |          |
-| chacha20-poly1305@openssh.com        | OK.                   | Requires the gem `rbnacl` |
+| chacha20-poly1305@openssh.com        | OK.                   | Backed by Ruby OpenSSL ChaCha20 and Poly1305 APIs (`openssl >= 3.2.0`) |
 | aes256-cbc / aes192-cbc / aes128-cbc | Deprecated in 6.0     | unsecure, will be removed in 8.0 |
 | rijndael-cbc@lysator.liu.se          | Deprecated in 6.0     | unsecure, will be removed in 8.0 |
 | blowfish-ctr blowfish-cbc            | Deprecated in 6.0     | unsecure, will be removed in 8.0 |
@@ -148,16 +148,16 @@ See Net::SSH for more documentation, and links to further information.
 
 ## REQUIREMENTS:
 
-The only requirement you might be missing is the OpenSSL bindings for Ruby with a version greather than `1.0.1`.
-These are built by default on most platforms, but you can verify that they're built and installed on your system by running the following command line:
+Net::SSH requires Ruby 2.7 or newer and the Ruby `openssl` gem version `3.2.0` or newer.
+The `openssl` gem uses the OpenSSL library Ruby is built against. You can verify the loaded gem and library with:
 
 ```sh
-ruby -ropenssl -e 'puts OpenSSL::OPENSSL_VERSION'
+ruby -ropenssl -e 'puts OpenSSL::VERSION; puts OpenSSL::OPENSSL_VERSION'
 ```
 
-If that spits out something like `OpenSSL 1.0.1 14 Mar 2012`, then you're set.
-If you get an error, then you'll need to see about rebuilding ruby with OpenSSL support,
-or (if your platform supports it) installing the OpenSSL bindings separately.
+If `openssl` cannot be required, rebuild Ruby with OpenSSL support or install the Ruby `openssl` gem separately.
+
+Ed25519, curve25519-sha256, and chacha20-poly1305@openssh.com support also require an OpenSSL backend with Ed25519, X25519, ChaCha20, and Poly1305 enabled.
 
 ## INSTALL:
 
@@ -188,15 +188,12 @@ gem install net-ssh -P HighSecurity
 If you don't add the public key, you'll see an error like "Couldn't verify data signature".
 If you're still having trouble let me know and I'll give you a hand.
 
-For ed25519 public key auth support your bundle file should contain `ed25519`, `bcrypt_pbkdf` dependencies.
+Ed25519 public key auth is backed by Ruby OpenSSL. The `bcrypt_pbkdf` gem is only needed when loading bcrypt-encrypted OpenSSH private keys.
 
 ```sh
-gem install ed25519
 gem install bcrypt_pbkdf
 ```
 
-For curve25519-sha256 kex exchange support your bundle file should contain `x25519` dependency.
-
 ## RUBY SUPPORT
 
 * See [net-ssh.gemspec](https://github.com/net-ssh/net-ssh/blob/master/net-ssh.gemspec) for current versions ruby requirements

data/appveyor.yml

@@ -4,16 +4,9 @@ skip_tags: true
 
 environment:
   matrix:
-    - ruby_version: "jruby-9.1.2.0"
-    - ruby_version: "26-x64"
-    - ruby_version: "25-x64"
-    - ruby_version: "24-x64"
-    - ruby_version: "23"
-    - ruby_version: "23-x64"
-
-matrix:
-  allow_failures:
-    - ruby_version: "jruby-9.1.2.0"
+    - ruby_version: "31-x64"
+    - ruby_version: "30-x64"
+    - ruby_version: "27-x64"
 
 #init:
 #  - ps: iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))
@@ -27,12 +20,8 @@ platform:
 
 install:
   - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
-  - if "%ruby_version%" == "jruby-9.1.2.0" ( cinst javaruntime -i )
-  - if "%ruby_version%" == "jruby-9.1.2.0" ( cinst jruby --version 9.1.2.0 -i --allow-empty-checksums )
-  - if "%ruby_version%" == "jruby-9.1.2.0" ( SET "PATH=C:\jruby-9.1.2.0\bin\;%PATH%" )
   - ruby --version
-  - gem install bundler --no-document --user-install -v 1.17
-  - SET BUNDLE_GEMFILE=Gemfile.noed25519
+  - gem install bundler --no-document --user-install -v 2.4.22
   - bundle install --retry=3
   - cinst freesshd
   - cinst putty --allow-empty-checksums
@@ -51,7 +40,6 @@ install:
           }
 
 test_script:
-  - SET BUNDLE_GEMFILE=Gemfile.noed25519
   - SET NET_SSH_RUN_WIN_INTEGRATION_TESTS=YES
   - bundle exec rake test
 

data/docker-compose.yml

@@ -13,11 +13,5 @@ services:
     build:
       context: .
       args: 
-        RUBY_VERSION: 2.7
+        RUBY_VERSION: 2.7.8
         BUNDLERV: "-v 2.2.28"
-  ruby-2.6:
-    build:
-      context: .
-      args: 
-        RUBY_VERSION: 2.6
-        BUNDLERV: "-v 2.4.22"

data/lib/net/ssh/authentication/agent.rb

@@ -261,13 +261,13 @@ module Net
           when /^ecdsa\-sha2\-(\w*)-cert-v01@openssh\.com$/
             Net::SSH::Buffer.from(:string, priv_key.to_blob, :bignum, priv_key.key.private_key).to_s
           when /^ssh-ed25519$/
-            Net::SSH::Buffer.from(:string, priv_key.public_key.verify_key.to_bytes,
-                                  :string, priv_key.sign_key.keypair).to_s
+            Net::SSH::Buffer.from(:string, priv_key.public_key_bytes,
+                                  :string, priv_key.private_key_bytes_for_agent).to_s
           when /^ssh-ed25519-cert-v01@openssh\.com$/
             # Unlike the other certificate types, the public key is included after the certifiate.
             Net::SSH::Buffer.from(:string, priv_key.to_blob,
-                                  :string, priv_key.key.public_key.verify_key.to_bytes,
-                                  :string, priv_key.key.sign_key.keypair).to_s
+                                  :string, priv_key.key.public_key_bytes,
+                                  :string, priv_key.key.private_key_bytes_for_agent).to_s
           when /^ssh-rsa$/
             # `n` and `e` are reversed compared to the ordering in `OpenSSL::PKey::RSA#to_blob`.
             Net::SSH::Buffer.from(:bignum, priv_key.n, :bignum, priv_key.e, :bignum, priv_key.d,

data/lib/net/ssh/authentication/ed25519.rb

@@ -1,25 +1,57 @@
-gem 'ed25519', '~> 1.2'
-gem 'bcrypt_pbkdf', '~> 1.0' unless RUBY_PLATFORM == "java"
-
-require 'ed25519'
-
+require 'openssl'
 require 'net/ssh/transport/cipher_factory'
 require 'net/ssh/authentication/pub_key_fingerprint'
-require 'bcrypt_pbkdf' unless RUBY_PLATFORM == "java"
 
 module Net
   module SSH
     module Authentication
       module ED25519
-        class SigningKeyFromFile < SimpleDelegator
-          def initialize(pk, sk)
-            key = ::Ed25519::SigningKey.from_keypair(sk)
-            raise ArgumentError, "pk does not match sk" unless pk == key.verify_key.to_bytes
+        ALGORITHM = "ED25519"
+        KEY_BYTES = 32
+        PRIVATE_KEY_BYTES = 64
 
-            super(key)
+        class UnsupportedError < StandardError; end
+
+        def self.ensure_supported!
+          unless OpenSSL::PKey.respond_to?(:new_raw_public_key) && OpenSSL::PKey.respond_to?(:new_raw_private_key)
+            raise UnsupportedError, "OpenSSL::PKey raw public/private key APIs are unavailable"
           end
+
+          key = new_private_key("\x00" * KEY_BYTES)
+          signature = sign(key, "")
+          public_key = new_public_key(key.raw_public_key)
+          raise UnsupportedError, "OpenSSL Ed25519 signature verification failed" unless verify(public_key, signature, "")
+        rescue OpenSSL::PKey::PKeyError => e
+          raise UnsupportedError, e.message
         end
 
+        def self.new_public_key(key)
+          validate_key_bytes!(key, "public key", KEY_BYTES)
+          OpenSSL::PKey.new_raw_public_key(ALGORITHM, binary_string(key))
+        end
+
+        def self.new_private_key(key)
+          validate_key_bytes!(key, "private key", KEY_BYTES)
+          OpenSSL::PKey.new_raw_private_key(ALGORITHM, binary_string(key))
+        end
+
+        def self.sign(key, data)
+          key.sign(nil, data)
+        end
+
+        def self.verify(key, signature, data)
+          key.verify(nil, signature, data)
+        end
+
+        def self.validate_key_bytes!(key, label, expected_bytes)
+          raise ArgumentError, "invalid Ed25519 #{label}" unless key.respond_to?(:bytesize) && key.bytesize == expected_bytes
+        end
+
+        def self.binary_string(string)
+          string.dup.force_encoding('BINARY')
+        end
+        private_class_method :binary_string
+
         class OpenSSHPrivateKeyLoader
           CipherFactory = Net::SSH::Transport::CipherFactory
 
@@ -47,7 +79,7 @@ module Net
             data = datab64.unpack1("m")
             raise ArgumentError.new("Expected #{MAGIC} at start of decoded private key") unless data.start_with?(MAGIC)
 
-            buffer = Net::SSH::Buffer.new(data[MAGIC.size + 1..-1])
+            buffer = Net::SSH::Buffer.new(data[(MAGIC.size + 1)..-1])
 
             ciphername = buffer.read_string
             raise ArgumentError.new("#{ciphername} in private key is not supported") unless
@@ -63,27 +95,34 @@ module Net
             _pubkey = buffer.read_string
 
             len = buffer.read_long
+            encrypted_private = buffer.read(len)
 
             keylen, blocksize, ivlen = CipherFactory.get_lengths(ciphername, iv_len: true)
             raise ArgumentError.new("Private key len:#{len} is not a multiple of #{blocksize}") if
-              ((len < blocksize) || ((blocksize > 0) && (len % blocksize) != 0))
+              (len < blocksize) || ((blocksize > 0) && (len % blocksize) != 0)
+
+            raise ArgumentError.new("Private key len:#{len} exceeds available data") unless encrypted_private.bytesize == len
+
+            authlen = CipherFactory.auth_length(ciphername)
+            auth_tag = authlen > 0 ? buffer.read(authlen) : nil
 
             if kdfname == 'bcrypt'
               salt = kdfopts.read_string
               rounds = kdfopts.read_long
 
-              raise "BCryptPbkdf is not implemented for jruby" if RUBY_PLATFORM == "java"
-
-              key = BCryptPbkdf::key(password, salt, keylen + ivlen, rounds)
-              raise DecryptError.new("BCyryptPbkdf failed", encrypted_key: true) unless key
+              key = bcrypt_pbkdf_key(password, salt, keylen + ivlen, rounds)
             else
-              key = '\x00' * (keylen + ivlen)
+              key = "\x00" * (keylen + ivlen)
             end
 
-            cipher = CipherFactory.get(ciphername, key: key[0...keylen], iv: key[keylen...keylen + ivlen], decrypt: true)
-
-            decoded = cipher.update(buffer.remainder_as_buffer.to_s)
-            decoded << cipher.final
+            decoded = decrypt_private_key(
+              ciphername,
+              encrypted_private,
+              auth_tag,
+              key: key[0...keylen],
+              iv: key[keylen...(keylen + ivlen)],
+              encrypted_key: kdfname == 'bcrypt'
+            )
 
             decoded = Net::SSH::Buffer.new(decoded)
             check1 = decoded.read_long
@@ -99,15 +138,49 @@ module Net
               decoded.read_private_keyblob(type_name)
             end
           end
+
+          def self.bcrypt_pbkdf_key(password, salt, length, rounds)
+            begin
+              require_bcrypt_pbkdf
+            rescue LoadError
+              raise DecryptError.new("bcrypt_pbkdf is required to decrypt bcrypt-encrypted OpenSSH private keys")
+            end
+
+            key = BCryptPbkdf::key(password, salt, length, rounds)
+            raise DecryptError.new("BCryptPbkdf failed", encrypted_key: true) unless key
+
+            key
+          end
+
+          def self.require_bcrypt_pbkdf
+            require 'bcrypt_pbkdf'
+          end
+
+          def self.decrypt_private_key(ciphername, encrypted_private, auth_tag, options)
+            if auth_tag
+              return CipherFactory.decrypt_private_key(
+                ciphername,
+                encrypted_private,
+                auth_tag,
+                options[:key],
+                options[:iv]
+              )
+            end
+
+            cipher = CipherFactory.get(ciphername, key: options[:key], iv: options[:iv], decrypt: true)
+            decoded = cipher.update(encrypted_private)
+            decoded << cipher.final
+          rescue Net::SSH::Exception, OpenSSL::Cipher::CipherError
+            raise DecryptError.new("Decrypt failed on private key", encrypted_key: options[:encrypted_key])
+          end
         end
 
         class PubKey
           include Net::SSH::Authentication::PubKeyFingerprint
 
-          attr_reader :verify_key
-
           def initialize(data)
-            @verify_key = ::Ed25519::VerifyKey.new(data)
+            ED25519.validate_key_bytes!(data, "public key", KEY_BYTES)
+            @public_key_bytes = data.dup.force_encoding('BINARY')
           end
 
           def self.read_keyblob(buffer)
@@ -115,7 +188,7 @@ module Net
           end
 
           def to_blob
-            Net::SSH::Buffer.from(:mstring, "ssh-ed25519".dup, :string, @verify_key.to_bytes).to_s
+            Net::SSH::Buffer.from(:mstring, "ssh-ed25519".dup, :string, public_key_bytes).to_s
           end
 
           def ssh_type
@@ -127,22 +200,26 @@ module Net
           end
 
           def ssh_do_verify(sig, data, options = {})
-            @verify_key.verify(sig, data)
+            ED25519.verify(verify_key, sig, data)
           end
 
           def to_pem
             # TODO this is not pem
-            ssh_type + [@verify_key.to_bytes].pack("m")
+            ssh_type + [public_key_bytes].pack("m")
+          end
+
+          def public_key_bytes
+            @public_key_bytes.dup
+          end
+
+          def verify_key
+            @verify_key ||= ED25519.new_public_key(@public_key_bytes)
           end
         end
 
         class PrivKey
           CipherFactory = Net::SSH::Transport::CipherFactory
 
-          MBEGIN = "-----BEGIN OPENSSH PRIVATE KEY-----\n"
-          MEND = "-----END OPENSSH PRIVATE KEY-----\n"
-          MAGIC = "openssh-key-v1"
-
           attr_reader :sign_key
 
           def initialize(buffer)
@@ -150,8 +227,17 @@ module Net
             sk = buffer.read_string
             _comment = buffer.read_string
 
-            @pk = pk
-            @sign_key = SigningKeyFromFile.new(pk, sk)
+            ED25519.validate_key_bytes!(pk, "public key", KEY_BYTES)
+            ED25519.validate_key_bytes!(sk, "private key field", PRIVATE_KEY_BYTES)
+
+            private_key_bytes = sk[0, KEY_BYTES]
+            raise ArgumentError, "Ed25519 private key does not include matching public key" unless sk[KEY_BYTES, KEY_BYTES] == pk
+
+            @sign_key = ED25519.new_private_key(private_key_bytes)
+            raise ArgumentError, "Ed25519 public key does not match private key" unless @sign_key.raw_public_key == pk
+
+            @public_key_bytes = pk.dup.force_encoding('BINARY')
+            @private_key_bytes = private_key_bytes.dup.force_encoding('BINARY')
           end
 
           def to_blob
@@ -167,11 +253,23 @@ module Net
           end
 
           def public_key
-            PubKey.new(@pk)
+            PubKey.new(public_key_bytes)
           end
 
           def ssh_do_sign(data, sig_alg = nil)
-            @sign_key.sign(data)
+            ED25519.sign(@sign_key, data)
+          end
+
+          def public_key_bytes
+            @public_key_bytes.dup
+          end
+
+          def private_key_bytes
+            @private_key_bytes.dup
+          end
+
+          def private_key_bytes_for_agent
+            private_key_bytes + public_key_bytes
           end
 
           def self.read(data, password)

data/lib/net/ssh/authentication/ed25519_loader.rb

@@ -1,29 +1,34 @@
 module Net
   module SSH
     module Authentication
-      # Loads ED25519 support which requires optinal dependecies like
-      # ed25519, bcrypt_pbkdf
+      # Loads ED25519 support backed by Ruby OpenSSL raw key APIs.
       module ED25519Loader
         begin
           require 'net/ssh/authentication/ed25519'
+          Net::SSH::Authentication::ED25519.ensure_supported!
           LOADED = true
           ERROR = nil
         rescue LoadError => e
           ERROR = e
           LOADED = false
+        rescue StandardError => e
+          if defined?(Net::SSH::Authentication::ED25519::UnsupportedError) &&
+             e.is_a?(Net::SSH::Authentication::ED25519::UnsupportedError)
+            ERROR = e
+            LOADED = false
+          else
+            raise
+          end
         end
 
         def self.raiseUnlessLoaded(message)
-          description = ERROR.is_a?(LoadError) ? dependenciesRequiredForED25519 : +''
-          description << "#{ERROR.class} : \"#{ERROR.message}\"\n" if ERROR
+          description = LOADED ? '' : ed25519SupportRequired
+          description += "#{ERROR.class} : \"#{ERROR.message}\"\n" if ERROR
           raise NotImplementedError, "#{message}\n#{description}" unless LOADED
         end
 
-        def self.dependenciesRequiredForED25519
-          result = +"net-ssh requires the following gems for ed25519 support:\n"
-          result << " * ed25519 (>= 1.2, < 2.0)\n"
-          result << " * bcrypt_pbkdf (>= 1.0, < 2.0)\n" unless RUBY_PLATFORM == "java"
-          result << "See https://github.com/net-ssh/net-ssh/issues/565 for more information\n"
+        def self.ed25519SupportRequired
+          "net-ssh requires openssl >= 3.2.0 and a crypto backend with Ed25519 enabled for ed25519 support.\n"
         end
       end
     end

data/lib/net/ssh/known_hosts.rb

@@ -61,6 +61,37 @@ module Net
             false
           end
         end
+
+        # Returns true if the certificate lists no principals (unrestricted) or
+        # if the given hostname matches a listed principal. Host-certificate
+        # principals are shell-glob patterns, matching OpenSSH, whose
+        # sshkey_cert_check_host passes wildcard_pattern=1 so principals like
+        # "*.example.com" are matched with match_pattern rather than strcmp.
+        def matches_principal?(server_key, hostname)
+          server_key.valid_principals.empty? ||
+            server_key.valid_principals.any? { |principal| File.fnmatch(principal, hostname) }
+        end
+
+        # Returns true if the certificate's validity window covers the current time.
+        def matches_validity?(server_key)
+          return false if server_key.valid_after && server_key.valid_after > Time.now
+          return false if server_key.valid_before && server_key.valid_before < Time.now
+
+          true
+        end
+
+        # Returns true if the certificate is a host certificate. A user
+        # certificate (type :user) must never authenticate a host.
+        def matches_type?(server_key)
+          server_key.type == :host
+        end
+
+        # Returns true if every critical option in the certificate is one we can
+        # enforce. net-ssh enforces none, so any critical option is unsupported
+        # and, as OpenSSH does, must cause the certificate to be rejected.
+        def critical_options_supported?(server_key)
+          server_key.critical_options.empty?
+        end
       end
     end
 
@@ -89,6 +120,17 @@ module Net
       def empty?
         @host_keys.empty?
       end
+
+      # Returns the bare hostname, stripping port and IP portions from the
+      # comma-separated host string used internally.
+      #
+      # Examples:
+      #   "server.example.com"            => "server.example.com"
+      #   "server.example.com,1.2.3.4"    => "server.example.com"
+      #   "[server.example.com]:2222"      => "server.example.com"
+      def hostname
+        @host.split(",").first.gsub(/\[|\]:\d+/, "")
+      end
     end
 
     # Searches an OpenSSH-style known-host file for a given host, and returns all