net-ssh 7.3.6 → 8.1.2

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
 
@@ -41,13 +73,8 @@ module Net
             end
           end
 
-          def self.check_bcrypt_kdf!(rounds, password)
-            raise ArgumentError.new("Private key bcrypt rounds #{rounds} exceeds #{MAX_KDF_ROUNDS}") if rounds > MAX_KDF_ROUNDS
-            raise DecryptError.new("Passphrase required for encrypted private key", encrypted_key: true) if password.nil? || password.empty?
-          end
-
           def self.read(datafull, password)
-            datafull = datafull.strip
+            datafull = datafull.strip.encode(universal_newline: true)
             raise ArgumentError.new("Expected #{MBEGIN} at start of private key") unless datafull.start_with?(MBEGIN)
             raise ArgumentError.new("Expected #{MEND} at end of private key") unless datafull.end_with?(MEND)
 
@@ -55,7 +82,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
@@ -71,29 +98,35 @@ 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 ArgumentError.new("Private key bcrypt rounds #{rounds} exceeds #{MAX_KDF_ROUNDS}") if rounds > MAX_KDF_ROUNDS
 
-              raise "BCryptPbkdf is not implemented for jruby" if RUBY_PLATFORM == "java"
-
-              check_bcrypt_kdf!(rounds, password)
-
-              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
@@ -109,15 +142,50 @@ 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
+            raise DecryptError.new("Passphrase required for encrypted private key", encrypted_key: true) if password.nil? || password.empty?
+
+            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)
@@ -125,7 +193,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
@@ -137,22 +205,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)
@@ -160,8 +232,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
@@ -177,11 +258,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/authentication/key_manager.rb

@@ -124,17 +124,16 @@ module Net
 
           user_identities = load_identities(prepared_identities, false, true)
 
-          if agent
-            agent.identities.each do |key|
-              corresponding_user_identity = user_identities.detect { |identity|
-                identity[:public_key] && identity[:public_key].to_pem == key.to_pem
-              }
-              user_identities.delete(corresponding_user_identity) if corresponding_user_identity
-
-              if !options[:keys_only] || corresponding_user_identity
-                known_identities[key] = { from: :agent, identity: key }
-                yield key
-              end
+          agent_identities.each do |key|
+            corresponding_user_identity = user_identities.detect { |identity|
+              identity[:public_key] && identity[:public_key].to_blob == key.to_blob
+            }
+            # By identity: EC::Point#== raises TypeError when compared with other key types.
+            user_identities.reject! { |identity| identity.equal?(corresponding_user_identity) }
+
+            if !options[:keys_only] || corresponding_user_identity
+              known_identities[key] = { from: :agent, identity: key }
+              yield key
             end
           end
 
@@ -246,6 +245,18 @@ module Net
 
         private
 
+        # Like OpenSSH's pubkey_prepare, an agent that fails to list its keys is
+        # dropped for the session so that key files are still tried.
+        def agent_identities
+          return [] unless agent
+
+          agent.identities
+        rescue AgentError => e
+          error { "could not get identities from agent: #{e.class} (#{e.message})" }
+          self.use_agent = false
+          []
+        end
+
         # Load keycerts from files and data.
         def keycerts
           keycert_files.map { |keycert_file| KeyFactory.load_public_key(keycert_file) } +

data/lib/net/ssh/authentication/methods/abstract.rb

@@ -20,9 +20,7 @@ module Net
           # this.
           attr_reader :key_manager
 
-          # So far only affects algorithms used for rsa keys, but can be
-          # extended to other keys, e.g after reading of
-          # PubkeyAcceptedAlgorithms option from ssh_config file is implemented.
+          # public key algorithms to be used
           attr_reader :pubkey_algorithms
 
           # Instantiates a new authentication method.
@@ -31,11 +29,7 @@ module Net
             @key_manager = options[:key_manager]
             @options = options
             @prompt = options[:password_prompt]
-            @pubkey_algorithms = options[:pubkey_algorithms] \
-              || %w[rsa-sha2-256-cert-v01@openssh.com
-                    ssh-rsa-cert-v01@openssh.com
-                    rsa-sha2-256
-                    ssh-rsa]
+            @pubkey_algorithms = session.transport.pubkey_algorithms
             self.logger = session.logger
           end
 
@@ -72,6 +66,10 @@ module Net
           private
 
           attr_reader :prompt
+
+          def fingerprint(identity)
+            identity.fingerprint(@options[:fingerprint_hash] || 'SHA256')
+          end
         end
       end
     end

data/lib/net/ssh/authentication/methods/hostbased.rb

@@ -31,7 +31,7 @@ module Net
           # Attempts to perform host-based authentication of the user, using
           # the given host identity (key).
           def authenticate_with(identity, next_service, username, key_manager)
-            debug { "trying hostbased (#{identity.fingerprint})" }
+            debug { "trying hostbased (#{fingerprint(identity)})" }
             client_username = ENV['USER'] || username
 
             req = build_request(identity, next_service, username, "#{hostname}.", client_username)
@@ -46,10 +46,10 @@ module Net
 
             case message.type
             when USERAUTH_SUCCESS
-              info { "hostbased succeeded (#{identity.fingerprint})" }
+              info { "hostbased succeeded (#{fingerprint(identity)})" }
               return true
             when USERAUTH_FAILURE
-              info { "hostbased failed (#{identity.fingerprint})" }
+              info { "hostbased failed (#{fingerprint(identity)})" }
 
               raise Net::SSH::Authentication::DisallowedMethod unless
                 message[:authentications].split(/,/).include? 'hostbased'

data/lib/net/ssh/authentication/methods/publickey.rb

@@ -8,6 +8,25 @@ module Net
       module Methods
         # Implements the "publickey" SSH authentication method.
         class Publickey < Abstract
+          RSA_CERT = "ssh-rsa-cert-v01@openssh.com".freeze
+
+          # Key algorithms usable with each RSA key type, mapped to the signature algorithm they imply.
+          RSA_SIGNATURE_ALGORITHMS = {
+            "ssh-rsa" => {
+              "rsa-sha2-512" => "rsa-sha2-512",
+              "rsa-sha2-256" => "rsa-sha2-256",
+              "ssh-rsa" => "ssh-rsa"
+            }.freeze,
+            RSA_CERT => {
+              "rsa-sha2-512-cert-v01@openssh.com" => "rsa-sha2-512",
+              "rsa-sha2-256-cert-v01@openssh.com" => "rsa-sha2-256",
+              RSA_CERT => "ssh-rsa"
+            }.freeze
+          }.freeze
+
+          # Servers that OpenSSH flags with SSH_BUG_SIGTYPE (compat.c): no RSA/SHA-2 certificate signatures.
+          SIGTYPE_BUG = /\A(OpenSSH_[2-5]|OpenSSH_6\.[56]|OpenSSH_7\.[0-7]|Sun_SSH_1\.0)/.freeze
+
           # Attempts to perform public-key authentication for the given
           # username, trying each identity known to the key manager. If any of
           # them succeed, returns +true+, otherwise returns +false+. This
@@ -15,6 +34,8 @@ module Net
           def authenticate(next_service, username, password = nil)
             return false unless key_manager
 
+            debug { "pubkey_algorithms: #{pubkey_algorithms.join(', ')}" }
+
             key_manager.each_identity do |identity|
               return true if authenticate_with(identity, next_service, username)
             end
@@ -44,7 +65,7 @@ module Net
           end
 
           def authenticate_with_alg(identity, next_service, username, alg, sig_alg = nil)
-            debug { "trying publickey (#{identity.fingerprint}) alg #{alg}" }
+            debug { "trying publickey (#{fingerprint(identity)}) alg #{alg}" }
             send_request(identity, username, next_service, alg)
 
             message = session.next_message
@@ -64,10 +85,10 @@ module Net
 
               case message.type
               when USERAUTH_SUCCESS
-                debug { "publickey succeeded (#{identity.fingerprint})" }
+                debug { "publickey succeeded (#{fingerprint(identity)})" }
                 return true
               when USERAUTH_FAILURE
-                debug { "publickey failed (#{identity.fingerprint})" }
+                debug { "publickey failed (#{fingerprint(identity)})" }
 
                 raise Net::SSH::Authentication::DisallowedMethod unless
                   message[:authentications].split(/,/).include? 'publickey'
@@ -92,43 +113,36 @@ module Net
           # username, with the given identity (public key). Returns +true+ if
           # successful, or +false+ otherwise.
           def authenticate_with(identity, next_service, username)
+            alg = key_algorithm(identity)
+            if alg.nil?
+              debug { "skipping publickey (#{identity.fingerprint}): no mutual signature algorithm for #{identity.ssh_type}" }
+              return false
+            end
+
+            authenticate_with_alg(identity, next_service, username, alg, RSA_SIGNATURE_ALGORITHMS.dig(identity.ssh_type, alg))
+          end
+
+          # Picks the single algorithm to offer for the identity, following
+          # key_sig_algorithm() in OpenSSH 10.2 sshconnect2.c.
+          def key_algorithm(identity)
             type = identity.ssh_type
-            if type == "ssh-rsa"
-              pubkey_algorithms.each do |pk_alg|
-                case pk_alg
-                when "rsa-sha2-512", "rsa-sha2-256", "ssh-rsa"
-                  if authenticate_with_alg(identity, next_service, username, pk_alg, pk_alg)
-                    # success
-                    return true
-                  end
-                end
-              end
-            elsif type == "ssh-rsa-cert-v01@openssh.com"
-              pubkey_algorithms.each do |pk_alg|
-                case pk_alg
-                when "rsa-sha2-512-cert-v01@openssh.com"
-                  if authenticate_with_alg(identity, next_service, username, pk_alg, "rsa-sha2-512")
-                    # success
-                    return true
-                  end
-                when "rsa-sha2-256-cert-v01@openssh.com"
-                  if authenticate_with_alg(identity, next_service, username, pk_alg, "rsa-sha2-256")
-                    # success
-                    return true
-                  end
-                when "ssh-rsa-cert-v01@openssh.com"
-                  if authenticate_with_alg(identity, next_service, username, pk_alg)
-                    # success
-                    return true
-                  end
-                end
-              end
-            elsif authenticate_with_alg(identity, next_service, username, type)
-              # success
-              return true
+            server_sig_algs = session.transport.server_sig_algs
+            server_software = session.transport.server_version.version.to_s.sub(/\ASSH-[\d.]+-/, "")
+
+            if server_sig_algs.nil? || !RSA_SIGNATURE_ALGORITHMS.key?(type) ||
+               (type == RSA_CERT && server_software.match?(SIGTYPE_BUG))
+              return type if pubkey_algorithms.include?(type)
+
+              return nil
+            end
+
+            # OpenSSH 7.4 accepts RSA/SHA-2 signatures but leaves them out of server-sig-algs.
+            server_sig_algs = %w[rsa-sha2-256 rsa-sha2-512] if type == "ssh-rsa" && server_software.start_with?("OpenSSH_7.4")
+
+            pubkey_algorithms.find do |alg|
+              sig_alg = RSA_SIGNATURE_ALGORITHMS[type][alg]
+              sig_alg && server_sig_algs.include?(sig_alg)
             end
-            # failure
-            return false
           end
         end
       end

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

@@ -0,0 +1,71 @@
+require 'net/ssh/errors'
+require 'net/ssh/authentication/pub_key_fingerprint'
+
+module Net
+  module SSH
+    module Authentication
+      # FIDO/U2F security keys held by ssh-agent. The agent does the signing (incl. user
+      # presence); net-ssh only parses and re-serialises the public key blob (see PROTOCOL.u2f).
+      module SecurityKey
+        SK_ECDSA_SHA2_NISTP256 = "sk-ecdsa-sha2-nistp256@openssh.com"
+        SK_SSH_ED25519 = "sk-ssh-ed25519@openssh.com"
+        TYPES = [SK_ECDSA_SHA2_NISTP256, SK_SSH_ED25519].freeze
+
+        def self.understands?(type)
+          TYPES.include?(type)
+        end
+
+        # Public key of an agent-held security key; signing is delegated to the agent.
+        class PubKey
+          include Net::SSH::Authentication::PubKeyFingerprint
+
+          attr_reader :ssh_type, :curve, :public_key_data, :application
+
+          # Wire formats:
+          #   sk-ecdsa-sha2-nistp256@openssh.com: string curve, string Q, string application
+          #   sk-ssh-ed25519@openssh.com:         string public_key, string application
+          def self.read_keyblob(type, buffer)
+            case type
+            when SK_ECDSA_SHA2_NISTP256
+              curve = buffer.read_string
+              public_key_data = buffer.read_string
+              application = buffer.read_string
+              new(type, public_key_data, application, curve: curve)
+            when SK_SSH_ED25519
+              public_key_data = buffer.read_string
+              application = buffer.read_string
+              new(type, public_key_data, application)
+            else
+              raise Net::SSH::UnsupportedKeyType, "unsupported security key type `#{type}'"
+            end
+          end
+
+          def initialize(ssh_type, public_key_data, application, curve: nil)
+            @ssh_type = ssh_type
+            @public_key_data = public_key_data
+            @application = application
+            @curve = curve
+          end
+
+          def to_blob
+            buffer = Net::SSH::Buffer.new
+            buffer.write_string(ssh_type)
+            buffer.write_string(curve) if curve
+            buffer.write_string(public_key_data)
+            buffer.write_string(application)
+            buffer.to_s
+          end
+
+          def ssh_signature_type
+            ssh_type
+          end
+
+          # Only used to de-duplicate identities, so a stable key-specific string suffices.
+          def to_pem
+            "#{ssh_type} #{[to_blob].pack('m0')}"
+          end
+        end
+      end
+    end
+  end
+end