[feature] Add protocol version validation for member and joiner (#248)

Author: paul-fresquet

src/ByteSync.Client/Business/Communications/PublicKeysTrusting/JoinerTrustProcessData.cs

@@ -13,6 +13,7 @@ public JoinerTrustProcessData()
 
         NonStoredPublicKeyCheckDatas = new List<PublicKeyCheckData>();
         FullyTrustedPublicKeyCheckDatas = new List<PublicKeyCheckData>();
+        IncompatibleMemberClientInstanceIds = new List<string>();
     }
 
     private List<string>? ExpectedPublicKeyCheckDataMembers { get; set; }
@@ -22,6 +23,10 @@ public JoinerTrustProcessData()
     public List<PublicKeyCheckData> NonStoredPublicKeyCheckDatas { get; }
 
     public List<PublicKeyCheckData> FullyTrustedPublicKeyCheckDatas { get; }
+    
+    public List<string> IncompatibleMemberClientInstanceIds { get; }
+    
+    public bool IsProtocolVersionIncompatible => IncompatibleMemberClientInstanceIds.Count > 0;
 
     private PublicKeyCheckData?[] ReceivedMembersPublicKeyCheckDatas { get; set; }
 
@@ -91,4 +96,14 @@ public ReadOnlyCollection<PublicKeyCheckData> GetReceivedPublicKeyCheckData()
             .ToList()
             .AsReadOnly();
     }
+    
+    public void SetProtocolVersionIncompatible(string memberClientInstanceId)
+    {
+        if (!IncompatibleMemberClientInstanceIds.Contains(memberClientInstanceId))
+        {
+            IncompatibleMemberClientInstanceIds.Add(memberClientInstanceId);
+        }
+        
+        WaitForAllPublicKeyCheckDatasReceived.Set();
+    }
 }

src/ByteSync.Client/Interfaces/Controls/Communications/Http/ITrustApiClient.cs

@@ -18,4 +18,6 @@ public interface ITrustApiClient
     Task SendDigitalSignatures(SendDigitalSignaturesParameters parameters, CancellationToken cancellationToken = default);
 
     Task SetAuthChecked(SetAuthCheckedParameters parameters, CancellationToken cancellationToken = default);
+    
+    Task InformProtocolVersionIncompatible(InformProtocolVersionIncompatibleParameters parameters, CancellationToken cancellationToken = default);
 }

src/ByteSync.Client/Interfaces/Controls/Communications/ITrustProcessPublicKeysRepository.cs

@@ -28,4 +28,8 @@ public interface ITrustProcessPublicKeysRepository : IRepository<TrustProcessPub
     Task<PublicKeyCheckData?> GetLocalPublicKeyCheckData(string sessionId, string joinerClientInstanceId);
 
     Task SetOtherPartyChecked(string sessionId, PublicKeyValidationParameters publicKeyValidationParameters);
+    
+    Task SetProtocolVersionIncompatible(string sessionId, string memberClientInstanceId);
+    
+    Task<bool> IsProtocolVersionIncompatible(string sessionId);
 }

src/ByteSync.Client/Interfaces/Controls/Communications/SignalR/IHubPushHandler2.cs

@@ -42,4 +42,5 @@ public interface IHubPushHandler2
     Subject<(string, LobbyCheckInfo)> LobbyCheckInfosSent { get; }
     Subject<(string, string, LobbyMemberStatuses)> LobbyMemberStatusUpdated { get; }
     Subject<LobbyCloudSessionCredentials> LobbyCloudSessionCredentialsSent { get; }
+    Subject<InformProtocolVersionIncompatibleParameters> InformProtocolVersionIncompatible { get; }
 }

src/ByteSync.Client/Services/Communications/Api/TrustApiClient.cs

@@ -102,6 +102,20 @@ public async Task SetAuthChecked(SetAuthCheckedParameters parameters, Cancellati
         }
     }
 
+    public async Task InformProtocolVersionIncompatible(InformProtocolVersionIncompatibleParameters parameters, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await _apiInvoker.PostAsync($"trust/informProtocolVersionIncompatible", parameters, cancellationToken);
+        }
+        catch (Exception ex)
+        {
+            LogError(ex);
+                
+            throw;
+        }
+    }
+
     private void LogError(Exception exception, [CallerMemberName] string caller = "")
     {
         // ReSharper disable once TemplateIsNotCompileTimeConstantProblem

src/ByteSync.Client/Services/Communications/PublicKeysTruster.cs

@@ -74,6 +74,27 @@ public async Task<JoinSessionResult> TrustAllMembersPublicKeys(string sessionId,
     // Called during StartTrustCheck on the session members so that they provide their PublicKeyCheckData to the joiner
     public async Task OnPublicKeyCheckDataAskedAsync((string sessionId, string clientInstanceId, PublicKeyInfo publicKeyInfo) tuple)
     {
+        // Validate protocol version compatibility before responding
+        if (!ProtocolVersion.IsCompatible(tuple.publicKeyInfo.ProtocolVersion))
+        {
+            _logger.LogWarning(
+                "Protocol version mismatch in OnPublicKeyCheckDataAskedAsync: joiner has version {JoinerVersion}, current version is {CurrentVersion}. Not responding to trust check request.",
+                tuple.publicKeyInfo.ProtocolVersion, ProtocolVersion.CURRENT);
+            
+            var incompatibleParameters = new InformProtocolVersionIncompatibleParameters
+            {
+                SessionId = tuple.sessionId,
+                MemberClientInstanceId = _environmentService.ClientInstanceId,
+                JoinerClientInstanceId = tuple.clientInstanceId,
+                MemberProtocolVersion = ProtocolVersion.CURRENT,
+                JoinerProtocolVersion = tuple.publicKeyInfo.ProtocolVersion
+            };
+            
+            await _trustApiClient.InformProtocolVersionIncompatible(incompatibleParameters);
+            
+            return;
+        }
+        
         var isTrusted = _publicKeysManager.IsTrusted(tuple.publicKeyInfo);
 
         var memberPublicKeyCheckData = _publicKeysManager.BuildMemberPublicKeyCheckData(tuple.publicKeyInfo, isTrusted);
@@ -272,6 +293,13 @@ private async Task<JoinSessionResult> InitiateAndWaitForTrustCheck(string sessio
 
         if (result == null || !result.IsOK)
         {
+            if (result is { IsProtocolVersionIncompatible: true })
+            {
+                _logger.LogWarning("StartTrustCheck returned protocol version incompatibility");
+                
+                return JoinSessionResult.BuildFrom(JoinSessionStatus.IncompatibleProtocolVersion);
+            }
+            
             _logger.LogError("Can not start trust check");
 
             return JoinSessionResult.BuildFrom(JoinSessionStatus.UnexpectedError);
@@ -285,6 +313,13 @@ private async Task<JoinSessionResult> InitiateAndWaitForTrustCheck(string sessio
 
         if (isWaitOK)
         {
+            if (await _trustProcessPublicKeysRepository.IsProtocolVersionIncompatible(sessionId))
+            {
+                _logger.LogWarning("Trust check interrupted due to protocol version incompatibility");
+                
+                return JoinSessionResult.BuildFrom(JoinSessionStatus.IncompatibleProtocolVersion);
+            }
+            
             return JoinSessionResult.BuildProcessingNormally();
         }
         else

src/ByteSync.Client/Services/Communications/PushReceivers/PublicKeyCheckDataPushReceiver.cs

@@ -29,6 +29,7 @@ public PublicKeyCheckDataPushReceiver(IHubPushHandler2 hubPushHandler2, IPublicK
         _hubPushHandler2.RequestTrustPublicKey.Subscribe(OnTrustPublicKeyRequested);
         _hubPushHandler2.InformPublicKeyValidationIsFinished.Subscribe(OnPublicKeyValidationIsFinished);
         _hubPushHandler2.RequestCheckDigitalSignature.Subscribe(OnRequestCheckDigitalSignature);
+        _hubPushHandler2.InformProtocolVersionIncompatible.Subscribe(OnProtocolVersionIncompatible);
     }
 
     private async void OnPublicKeyCheckDataAsked((string sessionId, string clientInstanceId, PublicKeyInfo publicKeyInfo) tuple)
@@ -91,4 +92,16 @@ private async void OnRequestCheckDigitalSignature(DigitalSignatureCheckInfo digi
             _logger.LogError(ex, "OnRequestCheckDigitalSignature");
         }
     }
+    
+    private async void OnProtocolVersionIncompatible(InformProtocolVersionIncompatibleParameters parameters)
+    {
+        try
+        {
+            await _trustProcessPublicKeysRepository.SetProtocolVersionIncompatible(parameters.SessionId, parameters.MemberClientInstanceId);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "OnProtocolVersionIncompatible");
+        }
+    }
 }

src/ByteSync.Client/Services/Communications/SignalR/HubPushHandler2.cs

@@ -71,7 +71,8 @@ public HubPushHandler2(IConnectionService connectionService, ILogger<HubPushHand
         new SubjectInfo<string, string>(nameof(IHubByteSyncPush.MemberQuittedLobby)),
         new SubjectInfo<string, LobbyCheckInfo>(nameof(IHubByteSyncPush.LobbyCheckInfosSent)),
         new SubjectInfo<string, string, LobbyMemberStatuses>(nameof(IHubByteSyncPush.LobbyMemberStatusUpdated)),
-        new SubjectInfo<LobbyCloudSessionCredentials>(nameof(IHubByteSyncPush.LobbyCloudSessionCredentialsSent))
+        new SubjectInfo<LobbyCloudSessionCredentials>(nameof(IHubByteSyncPush.LobbyCloudSessionCredentialsSent)),
+        new SubjectInfo<InformProtocolVersionIncompatibleParameters>(nameof(IHubByteSyncPush.InformProtocolVersionIncompatible))
     ];
 
     public Subject<(CloudSessionResult, ValidateJoinCloudSessionParameters)> YouJoinedSession => 
@@ -166,6 +167,9 @@ public HubPushHandler2(IConnectionService connectionService, ILogger<HubPushHand
 
     public Subject<LobbyCloudSessionCredentials> LobbyCloudSessionCredentialsSent => 
         GetSubject<LobbyCloudSessionCredentials>(nameof(IHubByteSyncPush.LobbyCloudSessionCredentialsSent));
+    
+    public Subject<InformProtocolVersionIncompatibleParameters> InformProtocolVersionIncompatible => 
+        GetSubject<InformProtocolVersionIncompatibleParameters>(nameof(IHubByteSyncPush.InformProtocolVersionIncompatible));
 
     private async Task SetConnection(HubConnection connection)
     {

src/ByteSync.Client/Services/Communications/TrustProcessPublicKeysRepository.cs

@@ -85,6 +85,19 @@ await RunAsync(sessionId, data =>
         });
     }
 
+    public async Task SetProtocolVersionIncompatible(string sessionId, string memberClientInstanceId)
+    {
+        await RunAsync(sessionId, data =>
+        {
+            data.JoinerTrustProcessData.SetProtocolVersionIncompatible(memberClientInstanceId);
+        });
+    }
+
+    public async Task<bool> IsProtocolVersionIncompatible(string sessionId)
+    {
+        return await GetAsync(sessionId, data => data.JoinerTrustProcessData.IsProtocolVersionIncompatible);
+    }
+
     protected override string GetDataId(TrustProcessPublicKeysData data)
     {
         return data.SessionId;

src/ByteSync.Common/Business/Sessions/Cloud/Connections/InformProtocolVersionIncompatibleParameters.cs

@@ -0,0 +1,14 @@
+namespace ByteSync.Common.Business.Sessions.Cloud.Connections;
+
+public class InformProtocolVersionIncompatibleParameters
+{
+    public string SessionId { get; set; } = null!;
+    
+    public string MemberClientInstanceId { get; set; } = null!;
+    
+    public string JoinerClientInstanceId { get; set; } = null!;
+    
+    public int MemberProtocolVersion { get; set; }
+    
+    public int JoinerProtocolVersion { get; set; }
+}