mysql-pr 2.9.11 → 3.0.0

data/lib/mysql-pr/charset.rb

@@ -1,31 +1,31 @@
+# frozen_string_literal: true
+
 # Copyright (C) 2008-2012 TOMITA Masahiro
 # mailto:tommy@tmtm.org
 
-#
 class MysqlPR
+  # MySQL character set and collation handling
   # @!attribute [r] number
-  #   @private
+  #   @return [Integer] charset number
   # @!attribute [r] name
   #   @return [String] charset name
   # @!attribute [r] csname
   #   @return [String] collation name
   class Charset
-    # @private
     # @param [Integer] number
     # @param [String] name
     # @param [String] csname
     def initialize(number, name, csname)
-      @number, @name, @csname = number, name, csname
+      @number = number
+      @name = name
+      @csname = csname
       @unsafe = false
     end
 
     attr_reader :number, :name, :csname
-
-    # @private
     attr_accessor :unsafe
 
     # [[charset_number, charset_name, collation_name, default], ...]
-    # @private
     CHARSETS = [
       [  1, "big5",     "big5_chinese_ci",       true ],
       [  2, "latin2",   "latin2_czech_cs",       false],
@@ -179,146 +179,117 @@ class MysqlPR
       [242, "utf8mb4",  "utf8mb4_hungarian_ci",  false],
       [243, "utf8mb4",  "utf8mb4_sinhala_ci",    false],
       [254, "utf8",     "utf8_general_cs",       false],
-    ]
+      [255, "utf8mb4",  "utf8mb4_0900_ai_ci",    false],
+    ].freeze
 
-    # @private
-    UNSAFE_CHARSET = [
-      "big5", "sjis", "filename", "gbk", "ucs2", "cp932",
-    ]
+    UNSAFE_CHARSET = %w[big5 sjis filename gbk ucs2 cp932].freeze
 
-    # @private
     NUMBER_TO_CHARSET = {}
-    # @private
     COLLATION_TO_CHARSET = {}
-    # @private
     CHARSET_DEFAULT = {}
+
     CHARSETS.each do |number, csname, clname, default|
-      cs = Charset.new number, csname, clname
-      cs.unsafe = true if UNSAFE_CHARSET.include? csname
+      cs = Charset.new(number, csname, clname)
+      cs.unsafe = true if UNSAFE_CHARSET.include?(csname)
       NUMBER_TO_CHARSET[number] = cs
       COLLATION_TO_CHARSET[clname] = cs
       CHARSET_DEFAULT[csname] = cs if default
     end
 
-    # @private
-    BINARY_CHARSET_NUMBER = CHARSET_DEFAULT['binary'].number
+    NUMBER_TO_CHARSET.freeze
+    COLLATION_TO_CHARSET.freeze
+    CHARSET_DEFAULT.freeze
 
-    # @private
-    # @param [Integer] n
-    # @return [Mysql::Charset]
+    BINARY_CHARSET_NUMBER = CHARSET_DEFAULT["binary"].number
+
+    # MySQL Charset -> Ruby Encoding mapping
+    CHARSET_ENCODING = {
+      "armscii8" => nil,
+      "ascii"    => Encoding::US_ASCII,
+      "big5"     => Encoding::Big5,
+      "binary"   => Encoding::ASCII_8BIT,
+      "cp1250"   => Encoding::Windows_1250,
+      "cp1251"   => Encoding::Windows_1251,
+      "cp1256"   => Encoding::Windows_1256,
+      "cp1257"   => Encoding::Windows_1257,
+      "cp850"    => Encoding::CP850,
+      "cp852"    => Encoding::CP852,
+      "cp866"    => Encoding::IBM866,
+      "cp932"    => Encoding::Windows_31J,
+      "dec8"     => nil,
+      "eucjpms"  => Encoding::EucJP_ms,
+      "euckr"    => Encoding::EUC_KR,
+      "gb2312"   => Encoding::EUC_CN,
+      "gbk"      => Encoding::GBK,
+      "geostd8"  => nil,
+      "greek"    => Encoding::ISO_8859_7,
+      "hebrew"   => Encoding::ISO_8859_8,
+      "hp8"      => nil,
+      "keybcs2"  => nil,
+      "koi8r"    => Encoding::KOI8_R,
+      "koi8u"    => Encoding::KOI8_U,
+      "latin1"   => Encoding::ISO_8859_1,
+      "latin2"   => Encoding::ISO_8859_2,
+      "latin5"   => Encoding::ISO_8859_9,
+      "latin7"   => Encoding::ISO_8859_13,
+      "macce"    => Encoding::MacCentEuro,
+      "macroman" => Encoding::MacRoman,
+      "sjis"     => Encoding::SHIFT_JIS,
+      "swe7"     => nil,
+      "tis620"   => Encoding::TIS_620,
+      "ucs2"     => Encoding::UTF_16BE,
+      "ujis"     => Encoding::EucJP_ms,
+      "utf8"     => Encoding::UTF_8,
+      "utf8mb4"  => Encoding::UTF_8,
+    }.freeze
+
+    # @param [Integer] n charset number
+    # @return [MysqlPR::Charset]
     def self.by_number(n)
-      raise ClientError, "unknown charset number: #{n}" unless NUMBER_TO_CHARSET.key? n
+      raise ClientError, "unknown charset number: #{n}" unless NUMBER_TO_CHARSET.key?(n)
+
       NUMBER_TO_CHARSET[n]
     end
 
-    # @private
-    # @param [String] str
-    # @return [Mysql::Charset]
+    # @param [String] str charset or collation name
+    # @return [MysqlPR::Charset]
     def self.by_name(str)
       ret = COLLATION_TO_CHARSET[str] || CHARSET_DEFAULT[str]
       raise ClientError, "unknown charset: #{str}" unless ret
+
       ret
     end
 
-    if defined? Encoding
-
-      # @private
-      # MySQL Charset -> Ruby's Encodeing
-      CHARSET_ENCODING = {
-        "armscii8" => nil,
-        "ascii"    => Encoding::US_ASCII,
-        "big5"     => Encoding::Big5,
-        "binary"   => Encoding::ASCII_8BIT,
-        "cp1250"   => Encoding::Windows_1250,
-        "cp1251"   => Encoding::Windows_1251,
-        "cp1256"   => Encoding::Windows_1256,
-        "cp1257"   => Encoding::Windows_1257,
-        "cp850"    => Encoding::CP850,
-        "cp852"    => Encoding::CP852,
-        "cp866"    => Encoding::IBM866,
-        "cp932"    => Encoding::Windows_31J,
-        "dec8"     => nil,
-        "eucjpms"  => Encoding::EucJP_ms,
-        "euckr"    => Encoding::EUC_KR,
-        "gb2312"   => Encoding::EUC_CN,
-        "gbk"      => Encoding::GBK,
-        "geostd8"  => nil,
-        "greek"    => Encoding::ISO_8859_7,
-        "hebrew"   => Encoding::ISO_8859_8,
-        "hp8"      => nil,
-        "keybcs2"  => nil,
-        "koi8r"    => Encoding::KOI8_R,
-        "koi8u"    => Encoding::KOI8_U,
-        "latin1"   => Encoding::ISO_8859_1,
-        "latin2"   => Encoding::ISO_8859_2,
-        "latin5"   => Encoding::ISO_8859_9,
-        "latin7"   => Encoding::ISO_8859_13,
-        "macce"    => Encoding::MacCentEuro,
-        "macroman" => Encoding::MacRoman,
-        "sjis"     => Encoding::SHIFT_JIS,
-        "swe7"     => nil,
-        "tis620"   => Encoding::TIS_620,
-        "ucs2"     => Encoding::UTF_16BE,
-        "ujis"     => Encoding::EucJP_ms,
-        "utf8"     => Encoding::UTF_8,
-        "utf8mb4"  => Encoding::UTF_8,
-      }
-
-      # @private
-      # @param [String] value
-      # @return [String]
-      def self.to_binary(value)
-        value.force_encoding Encoding::ASCII_8BIT
-      end
-
-      # @private
-      # convert raw to encoding and convert to Encoding.default_internal
-      # @param [String] raw
-      # @param [Encoding] encoding
-      # @return [String] result
-      def self.convert_encoding(raw, encoding)
-        raw.force_encoding(encoding).encode
-      end
-
-      # @private
-      # retrun corresponding Ruby encoding
-      # @return [Encoding] encoding
-      def encoding
-        enc = CHARSET_ENCODING[@name.downcase]
-        raise Mysql::ClientError, "unsupported charset: #{@name}" unless enc
-        enc
-      end
-
-      # @private
-      # convert encoding to corrensponding to MySQL charset
-      # @param [String] value
-      # @return [String]
-      def convert(value)
-        if value.is_a? String and value.encoding != Encoding::ASCII_8BIT
-          value = value.encode encoding
-        end
-        value
-      end
-
-    else
-      # for Ruby 1.8
+    # @param [String] value
+    # @return [String] value with binary encoding
+    def self.to_binary(value)
+      value.dup.force_encoding(Encoding::ASCII_8BIT)
+    end
 
-      def self.to_binary(value)
-        value
-      end
+    # Convert raw bytes to encoding and then to Encoding.default_internal
+    # @param [String] raw
+    # @param [Encoding] encoding
+    # @return [String]
+    def self.convert_encoding(raw, encoding)
+      raw.force_encoding(encoding).encode
+    end
 
-      def self.convert_encoding(raw, encoding)
-        raw
-      end
+    # @return [Encoding] corresponding Ruby encoding
+    def encoding
+      enc = CHARSET_ENCODING[@name.downcase]
+      raise MysqlPR::ClientError, "unsupported charset: #{@name}" unless enc
 
-      def encoding
-        nil
-      end
+      enc
+    end
 
-      def convert(value)
-        value
+    # Convert value encoding to match MySQL charset
+    # @param [String] value
+    # @return [String]
+    def convert(value)
+      if value.is_a?(String) && value.encoding != Encoding::ASCII_8BIT
+        value = value.encode(encoding)
       end
-
+      value
     end
   end
 end

data/lib/mysql-pr/constants.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (C) 2003-2008 TOMITA Masahiro
 # mailto:tommy@tmtm.org
 
@@ -52,6 +54,8 @@ class MysqlPR
   CLIENT_SECURE_CONNECTION = 1 << 15   # New 4.1 authentication
   CLIENT_MULTI_STATEMENTS  = 1 << 16   # Enable/disable multi-stmt support
   CLIENT_MULTI_RESULTS     = 1 << 17   # Enable/disable multi-results
+  CLIENT_PS_MULTI_RESULTS  = 1 << 18   # Multi-results in PS-protocol
+  CLIENT_PLUGIN_AUTH       = 1 << 19   # Client supports plugin authentication
 
   # Connection Option
   OPT_CONNECT_TIMEOUT         = 0

data/lib/mysql-pr/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (C) 2003-2010 TOMITA Masahiro
 # mailto:tommy@tmtm.org
 

data/lib/mysql-pr/packet.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 class MysqlPR
+  # Binary packet parsing for MySQL protocol
   class Packet
     # convert Numeric to LengthCodedBinary
     def self.lcb(num)
-      return "\xfb" if num.nil?
+      return "\xfb".b if num.nil?
       return [num].pack("C") if num < 251
       return [252, num].pack("Cv") if num < 65536
-      return [253, num&0xffff, num>>16].pack("CvC") if num < 16777216
-      return [254, num&0xffffffff, num>>32].pack("CVV")
+      return [253, num & 0xffff, num >> 16].pack("CvC") if num < 16_777_216
+      return [254, num & 0xffffffff, num >> 32].pack("CVV")
     end
 
     # convert String to LengthCodedString
@@ -66,7 +69,7 @@ class MysqlPR
     end
 
     def eof?
-      @data[0] == ?\xfe && @data.length == 5
+      @data.getbyte(0) == 0xfe && @data.length == 5
     end
 
     def to_s

data/lib/mysql-pr/protocol.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 # Copyright (C) 2008-2012 TOMITA Masahiro
 # mailto:tommy@tmtm.org
 
 require "socket"
 require "timeout"
 require "digest/sha1"
+require "digest/sha2"
 require "stringio"
+require "openssl"
 
 class MysqlPR
   # MySQL network protocol
@@ -151,15 +155,18 @@ class MysqlPR
     # conn_timeout :: [Integer] connect timeout (sec).
     # read_timeout :: [Integer] read timeout (sec).
     # write_timeout :: [Integer] write timeout (sec).
+    # ssl_options :: [Hash / nil] SSL options. nil means no SSL.
     # === Exception
     # [ClientError] :: connection timeout
-    def initialize(host, port, socket, conn_timeout, read_timeout, write_timeout)
+    def initialize(host, port, socket, conn_timeout, read_timeout, write_timeout, ssl_options = nil)
       @insert_id = 0
       @warning_count = 0
       @gc_stmt_queue = []   # stmt id list which GC destroy.
       set_state :INIT
       @read_timeout = read_timeout
       @write_timeout = write_timeout
+      @ssl_options = ssl_options
+      @ssl_enabled = false
       begin
         Timeout.timeout conn_timeout do
           if host.nil? or host.empty? or host == "localhost"
@@ -175,6 +182,18 @@ class MysqlPR
       end
     end
 
+    # Returns true if SSL is enabled for this connection
+    def ssl_enabled?
+      @ssl_enabled
+    end
+
+    # Returns SSL cipher info if SSL is enabled
+    def ssl_cipher
+      return nil unless @ssl_enabled && @sock.respond_to?(:cipher)
+
+      @sock.cipher
+    end
+
     def close
       @sock.close
     end
@@ -197,6 +216,7 @@ class MysqlPR
       @server_version = init_packet.server_version.split(/\D/)[0,3].inject{|a,b|a.to_i*100+b.to_i}
       @thread_id = init_packet.thread_id
       client_flags = CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_TRANSACTIONS | CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION
+      client_flags |= CLIENT_PLUGIN_AUTH
       client_flags |= CLIENT_CONNECT_WITH_DB if db
       client_flags |= flag
       @charset = charset
@@ -204,12 +224,171 @@ class MysqlPR
         @charset = Charset.by_number(init_packet.server_charset)
         @charset.encoding       # raise error if unsupported charset
       end
-      netpw = encrypt_password passwd, init_packet.scramble_buff
-      write AuthenticationPacket.serialize(client_flags, 1024**3, @charset.number, user, netpw, db)
-      raise ProtocolError, 'The old style password is not supported' if read.to_s == "\xfe"
-      set_state :READY
+
+      # SSL handshake if requested and server supports it
+      if @ssl_options && (init_packet.server_capabilities & CLIENT_SSL) != 0
+        client_flags |= CLIENT_SSL
+        # Send SSL request packet (partial auth packet with SSL flag)
+        write SSLRequestPacket.serialize(client_flags, 1024**3, @charset.number)
+        # Upgrade connection to SSL
+        upgrade_to_ssl
+      elsif @ssl_options && @ssl_options[:required]
+        raise ClientError, "SSL required but server does not support SSL"
+      end
+
+      auth_plugin = init_packet.auth_plugin_name || "mysql_native_password"
+      scramble = init_packet.scramble_buff
+
+      # Choose password encryption based on auth plugin
+      if auth_plugin == "caching_sha2_password"
+        netpw = encrypt_password_sha256(passwd, scramble)
+      else
+        netpw = encrypt_password(passwd, scramble)
+      end
+
+      write AuthenticationPacket.serialize(client_flags, 1024**3, @charset.number, user, netpw, db, auth_plugin)
+
+      # Read response
+      response = read
+      response_data = response.to_s
+
+      # Handle different response types
+      case response_data.getbyte(0)
+      when 0x00
+        # OK packet - authentication successful
+        set_state :READY
+      when 0xfe
+        # Auth switch request
+        handle_auth_switch(response_data, passwd)
+      when 0x01
+        # More data - caching_sha2_password specific
+        handle_caching_sha2_more_data(response_data, passwd, scramble)
+      else
+        raise ProtocolError, "Unexpected auth response: #{response_data.getbyte(0)}"
+      end
     end
 
+    # Handle auth switch request
+    def handle_auth_switch(response_data, passwd)
+      # Parse auth switch request: 0xfe + plugin_name + scramble
+      pkt = Packet.new(response_data[1..])
+      plugin_name = pkt.string
+      scramble = pkt.to_s
+
+      if plugin_name == "mysql_native_password"
+        netpw = encrypt_password(passwd, scramble)
+        write netpw
+        read # OK or error
+        set_state :READY
+      elsif plugin_name == "caching_sha2_password"
+        netpw = encrypt_password_sha256(passwd, scramble)
+        write netpw
+        response = read
+        if response.to_s.getbyte(0) == 0x01
+          handle_caching_sha2_more_data(response.to_s, passwd, scramble)
+        else
+          set_state :READY
+        end
+      else
+        raise ProtocolError, "Unsupported auth plugin: #{plugin_name}"
+      end
+    end
+
+    # Handle caching_sha2_password "more data" response
+    def handle_caching_sha2_more_data(response_data, passwd, scramble)
+      # 0x01 + status byte
+      status = response_data.getbyte(1)
+
+      case status
+      when 0x03
+        # Fast auth success - server already has cached password hash
+        read # Read the final OK packet
+        set_state :READY
+      when 0x04
+        # Full authentication required
+        if @ssl_enabled
+          # Send plaintext password over SSL
+          write "#{passwd}\x00"
+          read # OK or error
+          set_state :READY
+        else
+          # Need RSA encryption - request public key
+          write "\x02" # Request public key
+          pubkey_response = read
+          pubkey_data = pubkey_response.to_s
+
+          if pubkey_data.getbyte(0) == 0x01
+            # Got public key
+            public_key = pubkey_data[1..]
+            encrypted_password = rsa_encrypt_password(passwd, scramble, public_key)
+            write encrypted_password
+            read # OK or error
+            set_state :READY
+          else
+            raise ProtocolError, "Failed to get server public key"
+          end
+        end
+      else
+        raise ProtocolError, "Unknown caching_sha2_password status: #{status}"
+      end
+    end
+
+    # RSA encrypt password for caching_sha2_password
+    def rsa_encrypt_password(passwd, scramble, public_key_pem)
+      # XOR password with scramble
+      passwd_bytes = "#{passwd}\x00".bytes
+      scramble_bytes = scramble.bytes
+      xored = passwd_bytes.each_with_index.map { |b, i| b ^ scramble_bytes[i % scramble_bytes.length] }
+
+      # Encrypt with RSA public key
+      rsa = OpenSSL::PKey::RSA.new(public_key_pem)
+      rsa.public_encrypt(xored.pack("C*"), OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)
+    end
+
+    private
+
+    # Upgrade the connection to SSL/TLS
+    def upgrade_to_ssl
+      ssl_context = OpenSSL::SSL::SSLContext.new
+
+      # Configure SSL context based on options
+      if @ssl_options[:ca]
+        ssl_context.ca_file = @ssl_options[:ca]
+      end
+      if @ssl_options[:cert]
+        ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(@ssl_options[:cert]))
+      end
+      if @ssl_options[:key]
+        ssl_context.key = OpenSSL::PKey::RSA.new(File.read(@ssl_options[:key]))
+      end
+      if @ssl_options[:ca_path]
+        ssl_context.ca_path = @ssl_options[:ca_path]
+      end
+
+      # Set verification mode
+      if @ssl_options[:verify] == false
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      else
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+
+      # Set minimum TLS version if specified
+      if @ssl_options[:min_version]
+        ssl_context.min_version = @ssl_options[:min_version]
+      end
+
+      # Wrap socket in SSL
+      ssl_socket = OpenSSL::SSL::SSLSocket.new(@sock, ssl_context)
+      ssl_socket.hostname = @ssl_options[:hostname] if @ssl_options[:hostname]
+      ssl_socket.sync_close = true
+      ssl_socket.connect
+
+      @sock = ssl_socket
+      @ssl_enabled = true
+    end
+
+    public
+
     # Quit command
     def quit_command
       synchronize do
@@ -508,8 +687,8 @@ class MysqlPR
 
       @sqlstate = "00000"
 
-      # Error packet
-      if ret[0] == ?\xff
+      # Error packet (use getbyte for encoding-safe comparison)
+      if ret.getbyte(0) == 0xff
         f, errno, marker, @sqlstate, message = ret.unpack("Cvaa5a*")
         unless marker == "#"
           f, errno, message = ret.unpack("Cva*")    # Version 4.0 Error
@@ -575,7 +754,7 @@ class MysqlPR
       end
     end
 
-    # Encrypt password
+    # Encrypt password for mysql_native_password (SHA1)
     # === Argument
     # plain    :: [String] plain password.
     # scramble :: [String] scramble code from initial packet.
@@ -588,6 +767,19 @@ class MysqlPR
       return hash_stage1.unpack("C*").zip(Digest::SHA1.digest(scramble+hash_stage2).unpack("C*")).map{|a,b| a^b}.pack("C*")
     end
 
+    # Encrypt password for caching_sha2_password (SHA256)
+    # === Argument
+    # plain    :: [String] plain password.
+    # scramble :: [String] scramble code from initial packet.
+    # === Return
+    # [String] encrypted password
+    def encrypt_password_sha256(plain, scramble)
+      return "" if plain.nil? or plain.empty?
+      hash_stage1 = Digest::SHA256.digest(plain)
+      hash_stage2 = Digest::SHA256.digest(hash_stage1)
+      hash_stage1.unpack("C*").zip(Digest::SHA256.digest(hash_stage2 + scramble).unpack("C*")).map { |a, b| a ^ b }.pack("C*")
+    end
+
     # Initial packet
     class InitialPacket
       def self.parse(pkt)
@@ -599,18 +791,26 @@ class MysqlPR
         server_capabilities = pkt.ushort
         server_charset = pkt.utiny
         server_status = pkt.ushort
-        f1 = pkt.read(13)
-        rest_scramble_buff = pkt.string
+        server_capabilities_upper = pkt.ushort
+        auth_plugin_data_length = pkt.utiny
+        pkt.read(10) # reserved
+        # Read rest of scramble (12 bytes for caching_sha2_password, or variable)
+        rest_scramble_len = [auth_plugin_data_length - 8, 12].max
+        rest_scramble_buff = pkt.read(rest_scramble_len)
+        # Remove trailing null if present
+        rest_scramble_buff = rest_scramble_buff.sub(/\x00+\z/, "")
+        auth_plugin_name = pkt.string rescue "mysql_native_password"
         raise ProtocolError, "unsupported version: #{protocol_version}" unless protocol_version == VERSION
         raise ProtocolError, "invalid packet: f0=#{f0}" unless f0 == 0
         scramble_buff.concat rest_scramble_buff
-        self.new protocol_version, server_version, thread_id, server_capabilities, server_charset, server_status, scramble_buff
+        server_capabilities |= (server_capabilities_upper << 16)
+        self.new protocol_version, server_version, thread_id, server_capabilities, server_charset, server_status, scramble_buff, auth_plugin_name
       end
 
-      attr_reader :protocol_version, :server_version, :thread_id, :server_capabilities, :server_charset, :server_status, :scramble_buff
+      attr_reader :protocol_version, :server_version, :thread_id, :server_capabilities, :server_charset, :server_status, :scramble_buff, :auth_plugin_name
 
       def initialize(*args)
-        @protocol_version, @server_version, @thread_id, @server_capabilities, @server_charset, @server_status, @scramble_buff = args
+        @protocol_version, @server_version, @thread_id, @server_capabilities, @server_charset, @server_status, @scramble_buff, @auth_plugin_name = args
       end
     end
 
@@ -688,18 +888,34 @@ class MysqlPR
       end
     end
 
+    # SSL Request packet - sent before SSL handshake
+    class SSLRequestPacket
+      def self.serialize(client_flags, max_packet_size, charset_number)
+        [
+          client_flags,
+          max_packet_size,
+          charset_number,
+          ""                    # filler: 23 bytes of 0x00
+        ].pack("VVCa23")
+      end
+    end
+
     # Authentication packet
     class AuthenticationPacket
-      def self.serialize(client_flags, max_packet_size, charset_number, username, scrambled_password, databasename)
-        [
+      def self.serialize(client_flags, max_packet_size, charset_number, username, scrambled_password, databasename, auth_plugin_name = nil)
+        packet = [
           client_flags,
           max_packet_size,
-          Packet.lcb(charset_number),
-          "",                   # always 0x00 * 23
-          username,
-          Packet.lcs(scrambled_password),
-          databasename
-        ].pack("VVa*a23Z*A*Z*")
+          charset_number,
+          ""                    # reserved 23 bytes
+        ].pack("VVCa23")
+
+        packet << "#{username}\x00"
+        packet << Packet.lcs(scrambled_password)
+        packet << "#{databasename}\x00" if databasename && (client_flags & MysqlPR::CLIENT_CONNECT_WITH_DB) != 0
+        packet << "#{auth_plugin_name}\x00" if auth_plugin_name && (client_flags & MysqlPR::CLIENT_PLUGIN_AUTH) != 0
+
+        packet
       end
     end
 

data/lib/mysql-pr/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class MysqlPR
+  VERSION = "3.0.0"
+end