Added encryption and authentication capabilities to all internal send overloads

TwoTenPvP · TwoTenPvP · commit d95e2288e13a · 2018-08-10T16:35:06.000+02:00
diff --git a/MLAPI/MonoBehaviours/Core/NetworkingManager.cs b/MLAPI/MonoBehaviours/Core/NetworkingManager.cs
@@ -20,6 +20,7 @@
 using BitStream = MLAPI.Serialization.BitStream;
 using System.Runtime.CompilerServices;
 using System.Security.Cryptography.X509Certificates;
+using System.Text;
 
 namespace MLAPI
 {
@@ -796,7 +797,7 @@ internal void SendConnectionRequest()
                         writer.WriteByteArray(NetworkConfig.ConnectionData);
                 }
 
-                InternalMessageHandler.Send(ServerClientId, MLAPIConstants.MLAPI_CONNECTION_REQUEST, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(NetworkConfig.EnableEncryption, false), true);
+                InternalMessageHandler.Send(ServerClientId, MLAPIConstants.MLAPI_CONNECTION_REQUEST, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(true, false), true);
             }
         }
 
@@ -1017,7 +1018,7 @@ internal void OnClientDisconnectFromServer(uint clientId)
                     using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                     {
                         writer.WriteUInt32Packed(clientId);
-                        InternalMessageHandler.Send(MLAPIConstants.MLAPI_CLIENT_DISCONNECT, "MLAPI_INTERNAL", clientId, stream);
+                        InternalMessageHandler.Send(MLAPIConstants.MLAPI_CLIENT_DISCONNECT, "MLAPI_INTERNAL", clientId, stream, new InternalSecuritySendOptions(false, false));
                     }
                 }
             }
@@ -1033,7 +1034,7 @@ private void SyncTime()
                     writer.WriteSinglePacked(NetworkTime);
                     int timestamp = NetworkConfig.NetworkTransport.GetNetworkTimestamp();
                     writer.WriteInt32Packed(timestamp);
-                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_TIME_SYNC, "MLAPI_TIME_SYNC", stream);
+                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_TIME_SYNC, "MLAPI_TIME_SYNC", stream, new InternalSecuritySendOptions(false, false));
                 }
             }
         }
@@ -1113,7 +1114,7 @@ internal void HandleApproval(uint clientId, int prefabId, bool approved, Vector3
                             }
                         }
 
-                        InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CONNECTION_APPROVED, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(NetworkConfig.EnableEncryption, false), true);
+                        InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CONNECTION_APPROVED, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(true, false), true);
 
                         if (OnClientConnectedCallback != null)
                             OnClientConnectedCallback.Invoke(clientId);
diff --git a/MLAPI/NetworkingManagerComponents/Core/InternalMessageHandler.Send.cs b/MLAPI/NetworkingManagerComponents/Core/InternalMessageHandler.Send.cs
@@ -8,16 +8,16 @@ namespace MLAPI.Internal
 {
     internal static partial class InternalMessageHandler
     {
-        internal static void Send(uint clientId, byte messageType, string channelName, Stream messageStream, InternalSecuritySendOptions options, bool skipQueue = false)
+        internal static void Send(uint clientId, byte messageType, string channelName, Stream messageStream, InternalSecuritySendOptions securityOptions, bool skipQueue = false)
         {
             if (NetworkingManager.singleton.isServer && clientId == NetworkingManager.singleton.ServerClientId) return;
             using (PooledBitStream stream = PooledBitStream.Get())
             {
                 using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                 {
-                    writer.WriteBool(options.encrypted);
-                    writer.WriteBool(options.authenticated);
-                    if (options.encrypted && netManager.NetworkConfig.EnableEncryption)
+                    writer.WriteBool(securityOptions.encrypted);
+                    writer.WriteBool(securityOptions.authenticated);
+                    if (securityOptions.encrypted && netManager.NetworkConfig.EnableEncryption)
                     {
                         writer.WritePadBits();
                         using (RijndaelManaged rijndael = new RijndaelManaged())
@@ -38,7 +38,7 @@ internal static void Send(uint clientId, byte messageType, string channelName, S
                             }
                         }
                     }
-                    else if (options.authenticated && netManager.NetworkConfig.EnableEncryption)
+                    else if (securityOptions.authenticated && netManager.NetworkConfig.EnableEncryption)
                     {
                         writer.WritePadBits();
                         
@@ -66,8 +66,17 @@ internal static void Send(uint clientId, byte messageType, string channelName, S
             }
         }
 
-        internal static void Send(byte messageType, string channelName, Stream messageStream)
+        internal static void Send(byte messageType, string channelName, Stream messageStream, InternalSecuritySendOptions securityOptions)
         {
+            if (netManager.NetworkConfig.EnableEncryption && (securityOptions.authenticated || securityOptions.encrypted))
+            {
+                for (int i = 0; i < netManager.ConnectedClientsList.Count; i++)
+                {
+                    Send(netManager.ConnectedClientsList[i].ClientId, messageType, channelName, messageStream, securityOptions);
+                }
+                return;
+            }
+            
             using (PooledBitStream stream = PooledBitStream.Get())
             {
                 using (PooledBitWriter writer = PooledBitWriter.Get(stream))
@@ -87,8 +96,18 @@ internal static void Send(byte messageType, string channelName, Stream messageSt
             }
         }
         
-        internal static void Send(byte messageType, string channelName, uint clientIdToIgnore, Stream messageStream)
+        internal static void Send(byte messageType, string channelName, uint clientIdToIgnore, Stream messageStream, InternalSecuritySendOptions securityOptions)
         {
+            if (netManager.NetworkConfig.EnableEncryption && (securityOptions.authenticated || securityOptions.encrypted))
+            {
+                for (int i = 0; i < netManager.ConnectedClientsList.Count; i++)
+                {
+                    if (netManager.ConnectedClientsList[i].ClientId == clientIdToIgnore) continue;
+                    Send(netManager.ConnectedClientsList[i].ClientId, messageType, channelName, messageStream, securityOptions);
+                }
+                return;
+            }
+            
             using (PooledBitStream stream = PooledBitStream.Get())
             {
                 using (PooledBitWriter writer = PooledBitWriter.Get(stream))
diff --git a/MLAPI/NetworkingManagerComponents/Core/NetworkPoolManager.cs b/MLAPI/NetworkingManagerComponents/Core/NetworkPoolManager.cs
@@ -81,7 +81,7 @@ public static NetworkedObject SpawnPoolObject(string poolName, Vector3 position,
                     writer.WriteSinglePacked(rotation.eulerAngles.y);
                     writer.WriteSinglePacked(rotation.eulerAngles.z);
 
-                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_SPAWN_POOL_OBJECT, "MLAPI_INTERNAL", stream);
+                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_SPAWN_POOL_OBJECT, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(false, false));
                 }
             }
             return netObject;
@@ -105,7 +105,7 @@ public static void DestroyPoolObject(NetworkedObject netObject)
                 {
                     writer.WriteUInt32Packed(netObject.NetworkId);
 
-                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_POOL_OBJECT, "MLAPI_INTERNAL", stream);
+                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_POOL_OBJECT, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(false, false));
                 }
             }
         }
diff --git a/MLAPI/NetworkingManagerComponents/Core/NetworkSceneManager.cs b/MLAPI/NetworkingManagerComponents/Core/NetworkSceneManager.cs
@@ -67,7 +67,7 @@ public static void SwitchScene(string sceneName)
                 {
                     writer.WriteUInt32Packed(sceneNameToIndex[sceneName]);
 
-                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_SWITCH_SCENE, "MLAPI_INTERNAL", stream);
+                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_SWITCH_SCENE, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(false, false));
                 }
             }
         }
diff --git a/MLAPI/NetworkingManagerComponents/Core/SpawnManager.cs b/MLAPI/NetworkingManagerComponents/Core/SpawnManager.cs
@@ -81,7 +81,7 @@ internal static void RemoveOwnership(uint netId)
                     writer.WriteUInt32Packed(netId);
                     writer.WriteUInt32Packed(netObject.OwnerClientId);
 
-                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream);
+                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(false, false));
                 }
             }
         }
@@ -109,7 +109,7 @@ internal static void ChangeOwnership(uint netId, uint clientId)
                     writer.WriteUInt32Packed(netId);
                     writer.WriteUInt32Packed(clientId);
 
-                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream);
+                    InternalMessageHandler.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(false, false));
                 }
             }
         }
@@ -376,7 +376,7 @@ internal static void OnDestroyObject(uint networkId, bool destroyGameObject)
                         {
                             writer.WriteUInt32Packed(networkId);
 
-                            InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_OBJECT, "MLAPI_INTERNAL", stream);
+                            InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_OBJECT, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(false, false));
                         }
                     }
                 }

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@`
`20`	`20`	`using BitStream = MLAPI.Serialization.BitStream;`
`21`	`21`	`using System.Runtime.CompilerServices;`
`22`	`22`	`using System.Security.Cryptography.X509Certificates;`
	`23`	`+using System.Text;`
`23`	`24`
`24`	`25`	`namespace MLAPI`
`25`	`26`	`{`
`@@ -796,7 +797,7 @@ internal void SendConnectionRequest()`
`796`	`797`	`writer.WriteByteArray(NetworkConfig.ConnectionData);`
`797`	`798`	`}`
`798`	`799`
`799`		`- InternalMessageHandler.Send(ServerClientId, MLAPIConstants.MLAPI_CONNECTION_REQUEST, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(NetworkConfig.EnableEncryption, false), true);`
	`800`	`+ InternalMessageHandler.Send(ServerClientId, MLAPIConstants.MLAPI_CONNECTION_REQUEST, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(true, false), true);`
`800`	`801`	`}`
`801`	`802`	`}`
`802`	`803`
`@@ -1017,7 +1018,7 @@ internal void OnClientDisconnectFromServer(uint clientId)`
`1017`	`1018`	`using (PooledBitWriter writer = PooledBitWriter.Get(stream))`
`1018`	`1019`	`{`
`1019`	`1020`	`writer.WriteUInt32Packed(clientId);`
`1020`		`- InternalMessageHandler.Send(MLAPIConstants.MLAPI_CLIENT_DISCONNECT, "MLAPI_INTERNAL", clientId, stream);`
	`1021`	`+ InternalMessageHandler.Send(MLAPIConstants.MLAPI_CLIENT_DISCONNECT, "MLAPI_INTERNAL", clientId, stream, new InternalSecuritySendOptions(false, false));`
`1021`	`1022`	`}`
`1022`	`1023`	`}`
`1023`	`1024`	`}`
`@@ -1033,7 +1034,7 @@ private void SyncTime()`
`1033`	`1034`	`writer.WriteSinglePacked(NetworkTime);`
`1034`	`1035`	`int timestamp = NetworkConfig.NetworkTransport.GetNetworkTimestamp();`
`1035`	`1036`	`writer.WriteInt32Packed(timestamp);`
`1036`		`- InternalMessageHandler.Send(MLAPIConstants.MLAPI_TIME_SYNC, "MLAPI_TIME_SYNC", stream);`
	`1037`	`+ InternalMessageHandler.Send(MLAPIConstants.MLAPI_TIME_SYNC, "MLAPI_TIME_SYNC", stream, new InternalSecuritySendOptions(false, false));`
`1037`	`1038`	`}`
`1038`	`1039`	`}`
`1039`	`1040`	`}`
`@@ -1113,7 +1114,7 @@ internal void HandleApproval(uint clientId, int prefabId, bool approved, Vector3`
`1113`	`1114`	`}`
`1114`	`1115`	`}`
`1115`	`1116`
`1116`		`- InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CONNECTION_APPROVED, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(NetworkConfig.EnableEncryption, false), true);`
	`1117`	`+ InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CONNECTION_APPROVED, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(true, false), true);`
`1117`	`1118`
`1118`	`1119`	`if (OnClientConnectedCallback != null)`
`1119`	`1120`	`OnClientConnectedCallback.Invoke(clientId);`
Original file line number	Diff line number	Diff line change
`@@ -8,16 +8,16 @@ namespace MLAPI.Internal`
`8`	`8`	`{`
`9`	`9`	`internal static partial class InternalMessageHandler`
`10`	`10`	`{`
`11`		`- internal static void Send(uint clientId, byte messageType, string channelName, Stream messageStream, InternalSecuritySendOptions options, bool skipQueue = false)`
	`11`	`+ internal static void Send(uint clientId, byte messageType, string channelName, Stream messageStream, InternalSecuritySendOptions securityOptions, bool skipQueue = false)`
`12`	`12`	`{`
`13`	`13`	`if (NetworkingManager.singleton.isServer && clientId == NetworkingManager.singleton.ServerClientId) return;`
`14`	`14`	`using (PooledBitStream stream = PooledBitStream.Get())`
`15`	`15`	`{`
`16`	`16`	`using (PooledBitWriter writer = PooledBitWriter.Get(stream))`
`17`	`17`	`{`
`18`		`- writer.WriteBool(options.encrypted);`
`19`		`- writer.WriteBool(options.authenticated);`
`20`		`- if (options.encrypted && netManager.NetworkConfig.EnableEncryption)`
	`18`	`+ writer.WriteBool(securityOptions.encrypted);`
	`19`	`+ writer.WriteBool(securityOptions.authenticated);`
	`20`	`+ if (securityOptions.encrypted && netManager.NetworkConfig.EnableEncryption)`
`21`	`21`	`{`
`22`	`22`	`writer.WritePadBits();`
`23`	`23`	`using (RijndaelManaged rijndael = new RijndaelManaged())`
`@@ -38,7 +38,7 @@ internal static void Send(uint clientId, byte messageType, string channelName, S`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`	`}`
`41`		`- else if (options.authenticated && netManager.NetworkConfig.EnableEncryption)`
	`41`	`+ else if (securityOptions.authenticated && netManager.NetworkConfig.EnableEncryption)`
`42`	`42`	`{`
`43`	`43`	`writer.WritePadBits();`
`44`	`44`
`@@ -66,8 +66,17 @@ internal static void Send(uint clientId, byte messageType, string channelName, S`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`		`- internal static void Send(byte messageType, string channelName, Stream messageStream)`
	`69`	`+ internal static void Send(byte messageType, string channelName, Stream messageStream, InternalSecuritySendOptions securityOptions)`
`70`	`70`	`{`
	`71`	`+ if (netManager.NetworkConfig.EnableEncryption && (securityOptions.authenticated \|\| securityOptions.encrypted))`
	`72`	`+ {`
	`73`	`+ for (int i = 0; i < netManager.ConnectedClientsList.Count; i++)`
	`74`	`+ {`
	`75`	`+ Send(netManager.ConnectedClientsList[i].ClientId, messageType, channelName, messageStream, securityOptions);`
	`76`	`+ }`
	`77`	`+ return;`
	`78`	`+ }`
	`79`	`+`
`71`	`80`	`using (PooledBitStream stream = PooledBitStream.Get())`
`72`	`81`	`{`
`73`	`82`	`using (PooledBitWriter writer = PooledBitWriter.Get(stream))`
`@@ -87,8 +96,18 @@ internal static void Send(byte messageType, string channelName, Stream messageSt`
`87`	`96`	`}`
`88`	`97`	`}`
`89`	`98`
`90`		`- internal static void Send(byte messageType, string channelName, uint clientIdToIgnore, Stream messageStream)`
	`99`	`+ internal static void Send(byte messageType, string channelName, uint clientIdToIgnore, Stream messageStream, InternalSecuritySendOptions securityOptions)`
`91`	`100`	`{`
	`101`	`+ if (netManager.NetworkConfig.EnableEncryption && (securityOptions.authenticated \|\| securityOptions.encrypted))`
	`102`	`+ {`
	`103`	`+ for (int i = 0; i < netManager.ConnectedClientsList.Count; i++)`
	`104`	`+ {`
	`105`	`+ if (netManager.ConnectedClientsList[i].ClientId == clientIdToIgnore) continue;`
	`106`	`+ Send(netManager.ConnectedClientsList[i].ClientId, messageType, channelName, messageStream, securityOptions);`
	`107`	`+ }`
	`108`	`+ return;`
	`109`	`+ }`
	`110`	`+`
`92`	`111`	`using (PooledBitStream stream = PooledBitStream.Get())`
`93`	`112`	`{`
`94`	`113`	`using (PooledBitWriter writer = PooledBitWriter.Get(stream))`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ public static NetworkedObject SpawnPoolObject(string poolName, Vector3 position,`
`81`	`81`	`writer.WriteSinglePacked(rotation.eulerAngles.y);`
`82`	`82`	`writer.WriteSinglePacked(rotation.eulerAngles.z);`
`83`	`83`
`84`		`- InternalMessageHandler.Send(MLAPIConstants.MLAPI_SPAWN_POOL_OBJECT, "MLAPI_INTERNAL", stream);`
	`84`	`+ InternalMessageHandler.Send(MLAPIConstants.MLAPI_SPAWN_POOL_OBJECT, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(false, false));`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`	`return netObject;`
`@@ -105,7 +105,7 @@ public static void DestroyPoolObject(NetworkedObject netObject)`
`105`	`105`	`{`
`106`	`106`	`writer.WriteUInt32Packed(netObject.NetworkId);`
`107`	`107`
`108`		`- InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_POOL_OBJECT, "MLAPI_INTERNAL", stream);`
	`108`	`+ InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_POOL_OBJECT, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(false, false));`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ public static void SwitchScene(string sceneName)`
`67`	`67`	`{`
`68`	`68`	`writer.WriteUInt32Packed(sceneNameToIndex[sceneName]);`
`69`	`69`
`70`		`- InternalMessageHandler.Send(MLAPIConstants.MLAPI_SWITCH_SCENE, "MLAPI_INTERNAL", stream);`
	`70`	`+ InternalMessageHandler.Send(MLAPIConstants.MLAPI_SWITCH_SCENE, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(false, false));`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ internal static void RemoveOwnership(uint netId)`
`81`	`81`	`writer.WriteUInt32Packed(netId);`
`82`	`82`	`writer.WriteUInt32Packed(netObject.OwnerClientId);`
`83`	`83`
`84`		`- InternalMessageHandler.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream);`
	`84`	`+ InternalMessageHandler.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(false, false));`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`	`}`
`@@ -109,7 +109,7 @@ internal static void ChangeOwnership(uint netId, uint clientId)`
`109`	`109`	`writer.WriteUInt32Packed(netId);`
`110`	`110`	`writer.WriteUInt32Packed(clientId);`
`111`	`111`
`112`		`- InternalMessageHandler.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream);`
	`112`	`+ InternalMessageHandler.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(false, false));`
`113`	`113`	`}`
`114`	`114`	`}`
`115`	`115`	`}`
`@@ -376,7 +376,7 @@ internal static void OnDestroyObject(uint networkId, bool destroyGameObject)`
`376`	`376`	`{`
`377`	`377`	`writer.WriteUInt32Packed(networkId);`
`378`	`378`
`379`		`- InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_OBJECT, "MLAPI_INTERNAL", stream);`
	`379`	`+ InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_OBJECT, "MLAPI_INTERNAL", stream, new InternalSecuritySendOptions(false, false));`
`380`	`380`	`}`
`381`	`381`	`}`
`382`	`382`	`}`