Fixed public-key signature in key exchange and removed DSA support

TwoTenPvP · TwoTenPvP · commit 74fbd2a74315 · 2018-08-15T09:00:24.000+02:00
diff --git a/MLAPI/MonoBehaviours/Core/NetworkingManager.cs b/MLAPI/MonoBehaviours/Core/NetworkingManager.cs
@@ -683,19 +683,18 @@ private void Update()
                                                     X509Certificate2 certificate = NetworkConfig.ServerX509Certificate;
                                                     if (!certificate.HasPrivateKey) throw new CryptographicException("[MLAPI] No private key was found in server certificate. Unable to sign key exchange");
                                                     RSACryptoServiceProvider rsa = certificate.PrivateKey as RSACryptoServiceProvider;
-                                                    DSACryptoServiceProvider dsa = certificate.PrivateKey as DSACryptoServiceProvider;
 
                                                     if (rsa != null)
                                                     {
-                                                        hailWriter.WriteByteArray(rsa.SignData(diffieHellmanPublicPart, new SHA256Managed()));
-                                                    }
-                                                    else if (dsa != null)
-                                                    {
-                                                        using (SHA256Managed sha = new SHA256Managed())
+                                                        using (SHA256CryptoServiceProvider sha = new SHA256CryptoServiceProvider())
                                                         {
-                                                            hailWriter.WriteByteArray(dsa.CreateSignature(sha.ComputeHash(diffieHellmanPublicPart)));
+                                                            hailWriter.WriteByteArray(rsa.SignData(diffieHellmanPublicPart, sha));
                                                         }
                                                     }
+                                                    else
+                                                    {
+                                                        throw new CryptographicException("[MLAPI] Only RSA certificates are supported. No valid RSA key was found");
+                                                    }
                                                 }
                                             }
                                             // Send the hail
diff --git a/MLAPI/NetworkingManagerComponents/Core/InternalMessageHandler.Receive.cs b/MLAPI/NetworkingManagerComponents/Core/InternalMessageHandler.Receive.cs
@@ -11,15 +11,6 @@
 
 namespace MLAPI.Internal
 {
-    //NOTE FOR TOMORROW:
-    /*
-     * 
-     * Change connect flow. If encryption is not enabled. Just do the current flow.
-     * Otherwise, Do the new hail flow
-     * 
-     * REMEMBER: MAKE SURE TO CHECK THAT YOU CANT BYPASS THE HAIL FLOW BY SENDING CONNECTION REQUEST BEFORE HAIL.
-     * I.E ADD CHECKS
-     */
     internal static partial class InternalMessageHandler
     {
         // Runs on client
@@ -58,27 +49,17 @@ internal static void HandleHailRequest(uint clientId, Stream stream, int channel
                         byte[] serverDiffieHellmanPublicPartSignature = reader.ReadByteArray();
 
                         RSACryptoServiceProvider rsa = certificate.PublicKey.Key as RSACryptoServiceProvider;
-                        DSACryptoServiceProvider dsa = certificate.PublicKey.Key as DSACryptoServiceProvider;
 
                         if (rsa != null)
                         {
-                            if (!rsa.VerifyData(serverDiffieHellmanPublicPart, new SHA256Managed(), serverDiffieHellmanPublicPartSignature))
+                            using (SHA256CryptoServiceProvider sha = new SHA256CryptoServiceProvider())
                             {
-                                if (LogHelper.CurrentLogLevel <= LogLevel.Normal) if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Invalid signature. Disconnecting");
-                                netManager.StopClient();
-                                return;
-                            }
-                        }
-                        else if (dsa != null)
-                        {
-                            using (SHA256Managed sha = new SHA256Managed())
-                            {
-                                if (!dsa.VerifySignature(sha.ComputeHash(serverDiffieHellmanPublicPart), serverDiffieHellmanPublicPartSignature))
+                                if (!rsa.VerifyData(serverDiffieHellmanPublicPart, sha, serverDiffieHellmanPublicPartSignature))
                                 {
                                     if (LogHelper.CurrentLogLevel <= LogLevel.Normal) if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Invalid signature. Disconnecting");
                                     netManager.StopClient();
                                     return;
-                                }
+                                }   
                             }
                         }
                     }
@@ -99,19 +80,18 @@ internal static void HandleHailRequest(uint clientId, Stream stream, int channel
                         if (netManager.NetworkConfig.SignKeyExchange)
                         {
                             RSACryptoServiceProvider rsa = certificate.PublicKey.Key as RSACryptoServiceProvider;
-                            DSACryptoServiceProvider dsa = certificate.PublicKey.Key as DSACryptoServiceProvider;
 
                             if (rsa != null)
                             {
-                                writer.WriteByteArray(rsa.SignData(certificate.GetPublicKey(), new SHA256Managed()));
-                            }
-                            else if (dsa != null)
-                            {
-                                using (SHA256Managed sha = new SHA256Managed())
+                                using (SHA256CryptoServiceProvider sha = new SHA256CryptoServiceProvider())
                                 {
-                                    writer.WriteByteArray(dsa.CreateSignature(sha.ComputeHash(diffieHellmanPublicKey)));
+                                    writer.WriteByteArray(rsa.Encrypt(sha.ComputeHash(certificate.GetPublicKey()), false));   
                                 }
                             }
+                            else
+                            {
+                                throw new CryptographicException("[MLAPI] Only RSA certificates are supported. No valid RSA key was found");
+                            }
                         }
                     }
                 }
@@ -137,31 +117,36 @@ internal static void HandleHailResponse(uint clientId, Stream stream, int channe
                         byte[] diffieHellmanPublicSignature = reader.ReadByteArray();
                         X509Certificate2 certificate = netManager.NetworkConfig.ServerX509Certificate;
                         RSACryptoServiceProvider rsa = certificate.PublicKey.Key as RSACryptoServiceProvider;
-                        DSACryptoServiceProvider dsa = certificate.PublicKey.Key as DSACryptoServiceProvider;
 
                         if (rsa != null)
                         {
-                            if (!rsa.VerifyData(diffieHellmanPublic, new SHA256Managed(), diffieHellmanPublicSignature))
+                            using (SHA256CryptoServiceProvider sha = new SHA256CryptoServiceProvider())
                             {
-                                //Man in the middle.
-                                if (LogHelper.CurrentLogLevel <= LogLevel.Normal) if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Signature doesnt match for the key exchange public part. Disconnecting");
-                                netManager.DisconnectClient(clientId);
-                                return;
-                            }
-                        }
-                        else if (dsa != null)
-                        {
-                            using (SHA256Managed sha = new SHA256Managed())
-                            {
-                                if (!dsa.VerifySignature(sha.ComputeHash(diffieHellmanPublic), diffieHellmanPublicSignature))
+                                byte[] clientHash = rsa.Decrypt(diffieHellmanPublicSignature, false);
+                                byte[] serverHash = sha.ComputeHash(diffieHellmanPublic);
+                                if (clientHash.Length != serverHash.Length)
                                 {
                                     //Man in the middle.
-                                    if (LogHelper.CurrentLogLevel <= LogLevel.Normal) if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Signature doesnt match for the key exchange public part. Disconnecting");
+                                    if (LogHelper.CurrentLogLevel <= LogLevel.Normal) if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Signature length doesnt match for the key exchange public part. Disconnecting");
                                     netManager.DisconnectClient(clientId);
                                     return;
                                 }
+                                for (int i = 0; i < clientHash.Length; i++)
+                                {
+                                    if (clientHash[i] != serverHash[i])
+                                    {
+                                        //Man in the middle.
+                                        if (LogHelper.CurrentLogLevel <= LogLevel.Normal) if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Signature doesnt match for the key exchange public part. Disconnecting");
+                                        netManager.DisconnectClient(clientId);
+                                        return;
+                                    }
+                                }
                             }
                         }
+                        else
+                        {
+                            throw new CryptographicException("[MLAPI] Only RSA certificates are supported. No valid RSA key was found");
+                        }
                     }
                 }
             }

Original file line number	Diff line number	Diff line change
`@@ -683,19 +683,18 @@ private void Update()`
`683`	`683`	`X509Certificate2 certificate = NetworkConfig.ServerX509Certificate;`
`684`	`684`	`if (!certificate.HasPrivateKey) throw new CryptographicException("[MLAPI] No private key was found in server certificate. Unable to sign key exchange");`
`685`	`685`	`RSACryptoServiceProvider rsa = certificate.PrivateKey as RSACryptoServiceProvider;`
`686`		`- DSACryptoServiceProvider dsa = certificate.PrivateKey as DSACryptoServiceProvider;`
`687`	`686`
`688`	`687`	`if (rsa != null)`
`689`	`688`	`{`
`690`		`- hailWriter.WriteByteArray(rsa.SignData(diffieHellmanPublicPart, new SHA256Managed()));`
`691`		`- }`
`692`		`- else if (dsa != null)`
`693`		`- {`
`694`		`- using (SHA256Managed sha = new SHA256Managed())`
	`689`	`+ using (SHA256CryptoServiceProvider sha = new SHA256CryptoServiceProvider())`
`695`	`690`	`{`
`696`		`- hailWriter.WriteByteArray(dsa.CreateSignature(sha.ComputeHash(diffieHellmanPublicPart)));`
	`691`	`+ hailWriter.WriteByteArray(rsa.SignData(diffieHellmanPublicPart, sha));`
`697`	`692`	`}`
`698`	`693`	`}`
	`694`	`+ else`
	`695`	`+ {`
	`696`	`+ throw new CryptographicException("[MLAPI] Only RSA certificates are supported. No valid RSA key was found");`
	`697`	`+ }`
`699`	`698`	`}`
`700`	`699`	`}`
`701`	`700`	`// Send the hail`
Original file line number	Diff line number	Diff line change
`@@ -11,15 +11,6 @@`
`11`	`11`
`12`	`12`	`namespace MLAPI.Internal`
`13`	`13`	`{`
`14`		`- //NOTE FOR TOMORROW:`
`15`		`- /*`
`16`		`- *`
`17`		`- * Change connect flow. If encryption is not enabled. Just do the current flow.`
`18`		`- * Otherwise, Do the new hail flow`
`19`		`- *`
`20`		`- * REMEMBER: MAKE SURE TO CHECK THAT YOU CANT BYPASS THE HAIL FLOW BY SENDING CONNECTION REQUEST BEFORE HAIL.`
`21`		`- * I.E ADD CHECKS`
`22`		`- */`
`23`	`14`	`internal static partial class InternalMessageHandler`
`24`	`15`	`{`
`25`	`16`	`// Runs on client`
`@@ -58,27 +49,17 @@ internal static void HandleHailRequest(uint clientId, Stream stream, int channel`
`58`	`49`	`byte[] serverDiffieHellmanPublicPartSignature = reader.ReadByteArray();`
`59`	`50`
`60`	`51`	`RSACryptoServiceProvider rsa = certificate.PublicKey.Key as RSACryptoServiceProvider;`
`61`		`- DSACryptoServiceProvider dsa = certificate.PublicKey.Key as DSACryptoServiceProvider;`
`62`	`52`
`63`	`53`	`if (rsa != null)`
`64`	`54`	`{`
`65`		`- if (!rsa.VerifyData(serverDiffieHellmanPublicPart, new SHA256Managed(), serverDiffieHellmanPublicPartSignature))`
	`55`	`+ using (SHA256CryptoServiceProvider sha = new SHA256CryptoServiceProvider())`
`66`	`56`	`{`
`67`		`- if (LogHelper.CurrentLogLevel <= LogLevel.Normal) if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Invalid signature. Disconnecting");`
`68`		`- netManager.StopClient();`
`69`		`- return;`
`70`		`- }`
`71`		`- }`
`72`		`- else if (dsa != null)`
`73`		`- {`
`74`		`- using (SHA256Managed sha = new SHA256Managed())`
`75`		`- {`
`76`		`- if (!dsa.VerifySignature(sha.ComputeHash(serverDiffieHellmanPublicPart), serverDiffieHellmanPublicPartSignature))`
	`57`	`+ if (!rsa.VerifyData(serverDiffieHellmanPublicPart, sha, serverDiffieHellmanPublicPartSignature))`
`77`	`58`	`{`
`78`	`59`	`if (LogHelper.CurrentLogLevel <= LogLevel.Normal) if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Invalid signature. Disconnecting");`
`79`	`60`	`netManager.StopClient();`
`80`	`61`	`return;`
`81`		`- }`
	`62`	`+ }`
`82`	`63`	`}`
`83`	`64`	`}`
`84`	`65`	`}`
`@@ -99,19 +80,18 @@ internal static void HandleHailRequest(uint clientId, Stream stream, int channel`
`99`	`80`	`if (netManager.NetworkConfig.SignKeyExchange)`
`100`	`81`	`{`
`101`	`82`	`RSACryptoServiceProvider rsa = certificate.PublicKey.Key as RSACryptoServiceProvider;`
`102`		`- DSACryptoServiceProvider dsa = certificate.PublicKey.Key as DSACryptoServiceProvider;`
`103`	`83`
`104`	`84`	`if (rsa != null)`
`105`	`85`	`{`
`106`		`- writer.WriteByteArray(rsa.SignData(certificate.GetPublicKey(), new SHA256Managed()));`
`107`		`- }`
`108`		`- else if (dsa != null)`
`109`		`- {`
`110`		`- using (SHA256Managed sha = new SHA256Managed())`
	`86`	`+ using (SHA256CryptoServiceProvider sha = new SHA256CryptoServiceProvider())`
`111`	`87`	`{`
`112`		`- writer.WriteByteArray(dsa.CreateSignature(sha.ComputeHash(diffieHellmanPublicKey)));`
	`88`	`+ writer.WriteByteArray(rsa.Encrypt(sha.ComputeHash(certificate.GetPublicKey()), false));`
`113`	`89`	`}`
`114`	`90`	`}`
	`91`	`+ else`
	`92`	`+ {`
	`93`	`+ throw new CryptographicException("[MLAPI] Only RSA certificates are supported. No valid RSA key was found");`
	`94`	`+ }`
`115`	`95`	`}`
`116`	`96`	`}`
`117`	`97`	`}`
`@@ -137,31 +117,36 @@ internal static void HandleHailResponse(uint clientId, Stream stream, int channe`
`137`	`117`	`byte[] diffieHellmanPublicSignature = reader.ReadByteArray();`
`138`	`118`	`X509Certificate2 certificate = netManager.NetworkConfig.ServerX509Certificate;`
`139`	`119`	`RSACryptoServiceProvider rsa = certificate.PublicKey.Key as RSACryptoServiceProvider;`
`140`		`- DSACryptoServiceProvider dsa = certificate.PublicKey.Key as DSACryptoServiceProvider;`
`141`	`120`
`142`	`121`	`if (rsa != null)`
`143`	`122`	`{`
`144`		`- if (!rsa.VerifyData(diffieHellmanPublic, new SHA256Managed(), diffieHellmanPublicSignature))`
	`123`	`+ using (SHA256CryptoServiceProvider sha = new SHA256CryptoServiceProvider())`
`145`	`124`	`{`
`146`		`- //Man in the middle.`
`147`		`- if (LogHelper.CurrentLogLevel <= LogLevel.Normal) if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Signature doesnt match for the key exchange public part. Disconnecting");`
`148`		`- netManager.DisconnectClient(clientId);`
`149`		`- return;`
`150`		`- }`
`151`		`- }`
`152`		`- else if (dsa != null)`
`153`		`- {`
`154`		`- using (SHA256Managed sha = new SHA256Managed())`
`155`		`- {`
`156`		`- if (!dsa.VerifySignature(sha.ComputeHash(diffieHellmanPublic), diffieHellmanPublicSignature))`
	`125`	`+ byte[] clientHash = rsa.Decrypt(diffieHellmanPublicSignature, false);`
	`126`	`+ byte[] serverHash = sha.ComputeHash(diffieHellmanPublic);`
	`127`	`+ if (clientHash.Length != serverHash.Length)`
`157`	`128`	`{`
`158`	`129`	`//Man in the middle.`
`159`		`- if (LogHelper.CurrentLogLevel <= LogLevel.Normal) if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Signature doesnt match for the key exchange public part. Disconnecting");`
	`130`	`+ if (LogHelper.CurrentLogLevel <= LogLevel.Normal) if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Signature length doesnt match for the key exchange public part. Disconnecting");`
`160`	`131`	`netManager.DisconnectClient(clientId);`
`161`	`132`	`return;`
`162`	`133`	`}`
	`134`	`+ for (int i = 0; i < clientHash.Length; i++)`
	`135`	`+ {`
	`136`	`+ if (clientHash[i] != serverHash[i])`
	`137`	`+ {`
	`138`	`+ //Man in the middle.`
	`139`	`+ if (LogHelper.CurrentLogLevel <= LogLevel.Normal) if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("Signature doesnt match for the key exchange public part. Disconnecting");`
	`140`	`+ netManager.DisconnectClient(clientId);`
	`141`	`+ return;`
	`142`	`+ }`
	`143`	`+ }`
`163`	`144`	`}`
`164`	`145`	`}`
	`146`	`+ else`
	`147`	`+ {`
	`148`	`+ throw new CryptographicException("[MLAPI] Only RSA certificates are supported. No valid RSA key was found");`
	`149`	`+ }`
`165`	`150`	`}`
`166`	`151`	`}`
`167`	`152`	`}`