tried to implememnt handshake and related unit tests

Author: kerryjiang

.github/workflows/build.yml

@@ -0,0 +1,41 @@
+name: build
+
+on:
+    push:
+        branches:
+            - master
+
+jobs:
+    build:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v1
+            - name: Setup .NET Core
+              uses: actions/setup-dotnet@v3
+              with:
+                dotnet-version: '9.0.x'
+            - name: Set env
+              run: |
+                echo "DOTNET_CLI_TELEMETRY_OPTOUT=1" >> $GITHUB_ENV
+                echo "DOTNET_hostBuilder:reloadConfigOnChange=false" >> $GITHUB_ENV
+            - uses: dotnet/nbgv@master
+              id: nbgv
+            - name: Clean
+              run: |
+                dotnet clean ./SuperSocket.MySQL.sln --configuration Release
+                dotnet nuget locals all --clear
+            - name: Build
+              run: dotnet build -c Debug
+            - name: Run MySQL
+              run: |
+                cp tests/SuperSocket.MySQL.Test/mysql.cnf ~/.my.cnf
+                sudo systemctl start mysql.service
+                mysql -V
+            - name: Test
+              run: |
+                cd tests/SuperSocket.MySQL.Test
+                dotnet test
+            - name: Pack
+              run: dotnet pack -c Release -p:PackageVersion=${{ steps.nbgv.outputs.NuGetPackageVersion }}.${{ github.run_number }} -p:Version=${{ steps.nbgv.outputs.NuGetPackageVersion }}.${{ github.run_number }} -p:AssemblyVersion=${{ steps.nbgv.outputs.AssemblyVersion }} -p:AssemblyFileVersion=${{ steps.nbgv.outputs.AssemblyFileVersion }} -p:AssemblyInformationalVersion=${{ steps.nbgv.outputs.AssemblyInformationalVersion }} /p:NoPackageAnalysis=true /p:IncludeReleaseNotes=false
+            - name: Push
+              run: dotnet nuget push **/*.nupkg --api-key ${{ secrets.MYGET_API_KEY }} --source https://www.myget.org/F/supersocket/api/v3/index.json

.travis.yml

@@ -1,6 +1,8 @@
 using System;
 using System.Net;
 using System.Net.Sockets;
+using System.Security.Cryptography;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using SuperSocket.Client;
@@ -19,8 +21,14 @@ public class MySQLConnection : EasyClient<MySQLPacket>
 
         private static readonly MySQLPacketEncoder PacketEncoder = new MySQLPacketEncoder();
 
+        public bool IsAuthenticated { get; private set; }
+
         public MySQLConnection(string host, int port, string userName, string password)
-            : this(new MySQLPacketFactory().RegisterPacketType<HandshakeResponsePacket>(0x00))
+            : this(new MySQLPacketFactory()
+                .RegisterPacketType<HandshakePacket>(0x0A)
+                .RegisterPacketType<HandshakeResponsePacket>(0x00)
+                .RegisterPacketType<OKPacket>(0x00)
+                .RegisterPacketType<ErrorPacket>(0xFF))
         {
             _host = host ?? throw new ArgumentNullException(nameof(host));
             _port = port > 0 ? port : DefaultPort;
@@ -50,11 +58,127 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
 
             await ConnectAsync(endPoint, cancellationToken).ConfigureAwait(false);
 
-            // Send initial handshake packet
-            var handshakePacket = new HandshakePacket();
-            await SendAsync(PacketEncoder, handshakePacket).ConfigureAwait(false);
+            // Wait for server's handshake packet
+            var packet = await ReceiveAsync().ConfigureAwait(false);
+            if (!(packet is HandshakePacket handshakePacket))
+                throw new InvalidOperationException("Expected handshake packet from server.");
+
+            // Prepare handshake response
+            var handshakeResponse = new HandshakeResponsePacket
+            {
+                CapabilityFlags = (uint)(ClientCapabilities.CLIENT_PROTOCOL_41 | 
+                                       ClientCapabilities.CLIENT_SECURE_CONNECTION |
+                                       ClientCapabilities.CLIENT_PLUGIN_AUTH |
+                                       ClientCapabilities.CLIENT_CONNECT_WITH_DB),
+                MaxPacketSize = 16777216, // 16MB
+                CharacterSet = 0x21, // utf8_general_ci
+                Username = _userName,
+                Database = string.Empty, // Can be set later if needed
+                AuthPluginName = "mysql_native_password"
+            };
+
+            // Generate authentication response
+            handshakeResponse.AuthResponse = GenerateAuthResponse(handshakePacket);
+
+            // Send handshake response
+            await SendAsync(PacketEncoder, handshakeResponse).ConfigureAwait(false);
+
+            // Wait for authentication result (OK packet or Error packet)
+            var authResult = await ReceiveAsync().ConfigureAwait(false);
+            
+            switch (authResult)
+            {
+                case OKPacket okPacket:
+                    // Authentication successful
+                    IsAuthenticated = true;
+                    break;
+                case ErrorPacket errorPacket:
+                    // Authentication failed
+                    var errorMsg = !string.IsNullOrEmpty(errorPacket.ErrorMessage) 
+                        ? errorPacket.ErrorMessage 
+                        : "Authentication failed";
+                    throw new InvalidOperationException($"MySQL authentication failed: {errorMsg} (Error {errorPacket.ErrorCode})");
+                default:
+                    throw new InvalidOperationException($"Unexpected packet received during authentication: {authResult?.GetType().Name ?? "null"}");
+            }
+        }
+
+        private byte[] GenerateAuthResponse(HandshakePacket handshakePacket)
+        {
+            if (string.IsNullOrEmpty(_password))
+                return Array.Empty<byte>();
+
+            // Combine auth plugin data parts to form the complete salt
+            var salt = new byte[20];
+            handshakePacket.AuthPluginDataPart1?.CopyTo(salt, 0);
+            if (handshakePacket.AuthPluginDataPart2 != null)
+            {
+                var part2Length = Math.Min(handshakePacket.AuthPluginDataPart2.Length, 12);
+                Array.Copy(handshakePacket.AuthPluginDataPart2, 0, salt, 8, part2Length);
+            }
+
+            // MySQL native password authentication algorithm:
+            // SHA1(password) XOR SHA1(salt + SHA1(SHA1(password)))
+            using (var sha1 = SHA1.Create())
+            {
+                var passwordBytes = Encoding.UTF8.GetBytes(_password);
+                var sha1Password = sha1.ComputeHash(passwordBytes);
+                var sha1Sha1Password = sha1.ComputeHash(sha1Password);
+
+                var combined = new byte[salt.Length + sha1Sha1Password.Length];
+                salt.CopyTo(combined, 0);
+                sha1Sha1Password.CopyTo(combined, salt.Length);
 
-            // Handle authentication to be implemented here
+                var sha1Combined = sha1.ComputeHash(combined);
+
+                var result = new byte[sha1Password.Length];
+                for (int i = 0; i < sha1Password.Length; i++)
+                {
+                    result[i] = (byte)(sha1Password[i] ^ sha1Combined[i]);
+                }
+
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// Executes a simple query (placeholder implementation)
+        /// </summary>
+        /// <param name="query">The SQL query to execute</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <returns>Task representing the async operation</returns>
+        public async Task<string> ExecuteQueryAsync(string query, CancellationToken cancellationToken = default)
+        {
+            if (!IsAuthenticated)
+                throw new InvalidOperationException("Connection is not authenticated. Call ConnectAsync first.");
+
+            if (string.IsNullOrEmpty(query))
+                throw new ArgumentException("Query cannot be null or empty.", nameof(query));
+
+            // This is a placeholder implementation
+            // In a complete implementation, you would:
+            // 1. Create a COM_QUERY packet with the SQL query
+            // 2. Send the packet to the server
+            // 3. Receive and parse the result set
+            // 4. Return the results
+
+            await Task.Delay(10, cancellationToken); // Simulate async operation
+            return "Query execution not fully implemented yet";
+        }
+
+        /// <summary>
+        /// Disconnects from the MySQL server and resets authentication state
+        /// </summary>
+        public async Task DisconnectAsync()
+        {
+            try
+            {
+                await CloseAsync();
+            }
+            finally
+            {
+                IsAuthenticated = false;
+            }
         }
     }
 }

src/SuperSocket.MySQL/MySQLConnection.cs

@@ -0,0 +1,90 @@
+using System.Buffers;
+using System.Text;
+
+namespace SuperSocket.MySQL.Packets
+{
+    public class ErrorPacket : MySQLPacket
+    {
+        public byte Header { get; set; } = 0xFF; // Error packet identifier
+        public ushort ErrorCode { get; set; }
+        public string SqlStateMarker { get; set; } = "#";
+        public string SqlState { get; set; }
+        public string ErrorMessage { get; set; }
+
+        protected internal override void Decode(ref SequenceReader<byte> reader, object context)
+        {
+            // Read header (should be 0xFF for Error packet)
+            reader.TryRead(out byte header);
+            Header = header;
+            
+            // Read error code (2 bytes)
+            reader.TryReadLittleEndian(out short errorCode);
+            ErrorCode = (ushort)errorCode;
+            
+            // Check for SQL state marker and state (optional, depends on capability flags)
+            if (reader.Remaining >= 6 && reader.UnreadSequence.FirstSpan[0] == (byte)'#')
+            {
+                // Read SQL state marker
+                reader.TryRead(out byte marker);
+                SqlStateMarker = ((char)marker).ToString();
+                
+                // Read SQL state (5 characters)
+                var sqlStateBytes = new byte[5];
+                reader.TryCopyTo(sqlStateBytes);
+                reader.Advance(5);
+                SqlState = Encoding.UTF8.GetString(sqlStateBytes);
+            }
+            
+            // Read error message (rest of the packet)
+            if (reader.Remaining > 0)
+            {
+                var messageBytes = new byte[reader.Remaining];
+                reader.TryCopyTo(messageBytes);
+                reader.Advance((int)reader.Remaining);
+                ErrorMessage = Encoding.UTF8.GetString(messageBytes);
+            }
+        }
+
+        protected internal override int Encode(IBufferWriter<byte> writer)
+        {
+            var bytesWritten = 0;
+            
+            // Write header
+            bytesWritten += writer.WriteUInt8(Header);
+            
+            // Write error code
+            bytesWritten += writer.WriteUInt16(ErrorCode);
+            
+            // Write SQL state marker and state if present
+            if (!string.IsNullOrEmpty(SqlState))
+            {
+                var markerBytes = Encoding.UTF8.GetBytes(SqlStateMarker ?? "#");
+                var span = writer.GetSpan(markerBytes.Length);
+                for (int i = 0; i < markerBytes.Length; i++)
+                    span[i] = markerBytes[i];
+                writer.Advance(markerBytes.Length);
+                bytesWritten += markerBytes.Length;
+                
+                var sqlStateBytes = Encoding.UTF8.GetBytes(SqlState.PadRight(5).Substring(0, 5));
+                span = writer.GetSpan(5);
+                for (int i = 0; i < 5; i++)
+                    span[i] = sqlStateBytes[i];
+                writer.Advance(5);
+                bytesWritten += 5;
+            }
+            
+            // Write error message
+            if (!string.IsNullOrEmpty(ErrorMessage))
+            {
+                var messageBytes = Encoding.UTF8.GetBytes(ErrorMessage);
+                var span = writer.GetSpan(messageBytes.Length);
+                for (int i = 0; i < messageBytes.Length; i++)
+                    span[i] = messageBytes[i];
+                writer.Advance(messageBytes.Length);
+                bytesWritten += messageBytes.Length;
+            }
+            
+            return bytesWritten;
+        }
+    }
+}

src/SuperSocket.MySQL/Packets/ErrorPacket.cs

@@ -0,0 +1,74 @@
+using System.Buffers;
+
+namespace SuperSocket.MySQL.Packets
+{
+    public class OKPacket : MySQLPacket
+    {
+        public byte Header { get; set; } = 0x00; // OK packet identifier
+        public ulong AffectedRows { get; set; }
+        public ulong LastInsertId { get; set; }
+        public ushort StatusFlags { get; set; }
+        public ushort Warnings { get; set; }
+        public string Info { get; set; }
+
+        protected internal override void Decode(ref SequenceReader<byte> reader, object context)
+        {
+            // Read header (should be 0x00 for OK packet)
+            reader.TryRead(out byte header);
+            Header = header;
+            
+            // Read affected rows (length-encoded integer)
+            AffectedRows = reader.TryReadLengthEncodedInteger(out long affectedRows) ? (ulong)affectedRows : 0;
+            
+            // Read last insert ID (length-encoded integer)
+            LastInsertId = reader.TryReadLengthEncodedInteger(out long lastInsertId) ? (ulong)lastInsertId : 0;
+            
+            // Read status flags (2 bytes)
+            reader.TryReadLittleEndian(out short statusFlags);
+            StatusFlags = (ushort)statusFlags;
+            
+            // Read warnings (2 bytes)
+            reader.TryReadLittleEndian(out short warnings);
+            Warnings = (ushort)warnings;
+            
+            // Read info string if remaining data
+            if (reader.Remaining > 0)
+            {
+                Info = reader.TryReadLengthEncodedString(out string info) ? info : string.Empty;
+            }
+        }
+
+        protected internal override int Encode(IBufferWriter<byte> writer)
+        {
+            var bytesWritten = 0;
+            
+            // Write header
+            bytesWritten += writer.WriteUInt8(Header);
+            
+            // Write affected rows
+            bytesWritten += writer.WriteUInt64(AffectedRows);
+            
+            // Write last insert ID
+            bytesWritten += writer.WriteUInt64(LastInsertId);
+            
+            // Write status flags
+            bytesWritten += writer.WriteUInt16(StatusFlags);
+            
+            // Write warnings
+            bytesWritten += writer.WriteUInt16(Warnings);
+            
+            // Write info string if present
+            if (!string.IsNullOrEmpty(Info))
+            {
+                var infoBytes = System.Text.Encoding.UTF8.GetBytes(Info);
+                var span = writer.GetSpan(infoBytes.Length);
+                for (int i = 0; i < infoBytes.Length; i++)
+                    span[i] = infoBytes[i];
+                writer.Advance(infoBytes.Length);
+                bytesWritten += infoBytes.Length;
+            }
+            
+            return bytesWritten;
+        }
+    }
+}