private static void SendHandshakeReply(ClientObject client, HandshakeReply enumResponse, string reason) { ServerMessage newMessage = new ServerMessage(); newMessage.type = ServerMessageType.HANDSHAKE_REPLY; int response = (int)enumResponse; using (MessageWriter mw = new MessageWriter()) { mw.Write <int>(response); mw.Write <string>(reason); mw.Write <int>(Common.PROTOCOL_VERSION); mw.Write <string>(Common.PROGRAM_VERSION); if (response == 0) { mw.Write <bool>(Settings.settingsStore.compressionEnabled); mw.Write <int>((int)Settings.settingsStore.modControl); if (Settings.settingsStore.modControl != ModControlMode.DISABLED) { if (!File.Exists(Server.modFile)) { Server.GenerateNewModFile(); } string modFileData = File.ReadAllText(Server.modFile); mw.Write <string>(modFileData); } } newMessage.data = mw.GetMessageBytes(); } ClientHandler.SendToClient(client, newMessage, true); }
public static void SendHandshakeReply(ClientStructure client, HandshakeReply enumResponse, string reason) { var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <HandshakeReplyMsgData>(); msgData.Response = enumResponse; msgData.Reason = reason; if (enumResponse == HandshakeReply.HandshookSuccessfully) { msgData.ModControlMode = GeneralSettings.SettingsStore.ModControl; msgData.ServerStartTime = ServerContext.StartTime; msgData.PlayerId = client.Id; if (GeneralSettings.SettingsStore.ModControl != ModControlMode.Disabled) { if (!FileHandler.FileExists(ServerContext.ModFilePath)) { ModFileSystem.GenerateNewModFile(); } msgData.ModFileData = FileHandler.ReadFile(ServerContext.ModFilePath); msgData.NumBytes = msgData.ModFileData.Length; } } MessageQueuer.SendToClient <HandshakeSrvMsg>(client, msgData); }
internal override void InternalDeserialize(NetIncomingMessage lidgrenMsg) { base.InternalDeserialize(lidgrenMsg); Response = (HandshakeReply)lidgrenMsg.ReadInt32(); Reason = lidgrenMsg.ReadString(); ModControl = lidgrenMsg.ReadBoolean(); lidgrenMsg.SkipPadBits(); ServerStartTime = lidgrenMsg.ReadInt64(); ModFileData = lidgrenMsg.ReadString(); }
internal override void InternalDeserialize(NetIncomingMessage lidgrenMsg) { base.InternalDeserialize(lidgrenMsg); Response = (HandshakeReply)lidgrenMsg.ReadInt32(); Reason = lidgrenMsg.ReadString(); ModControlMode = (ModControlMode)lidgrenMsg.ReadInt32(); ServerStartTime = lidgrenMsg.ReadInt64(); PlayerId = GuidUtil.Deserialize(lidgrenMsg); NumBytes = lidgrenMsg.ReadInt32(); if (ModFileData.Length < NumBytes) { ModFileData = new byte[NumBytes]; } lidgrenMsg.ReadBytes(ModFileData, 0, NumBytes); }
public static void SendHandshakeReply(ClientStructure client, HandshakeReply enumResponse, string reason) { var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <HandshakeReplyMsgData>(); msgData.Response = enumResponse; msgData.Reason = reason; if (enumResponse == HandshakeReply.HandshookSuccessfully) { msgData.ModControl = GeneralSettings.SettingsStore.ModControl; msgData.ServerStartTime = TimeContext.StartTime.Ticks; if (GeneralSettings.SettingsStore.ModControl) { msgData.ModFileData = LunaXmlSerializer.SerializeToXml(ModFileSystem.ModControl); } } MessageQueuer.SendToClient <HandshakeSrvMsg>(client, msgData); }
public static void SendHandshakeReply(ClientStructure client, HandshakeReply enumResponse, string reason) { var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <HandshakeReplyMsgData>(); msgData.Response = enumResponse; msgData.Reason = reason; if (enumResponse == HandshakeReply.HandshookSuccessfully) { msgData.ModControl = GeneralSettings.SettingsStore.ModControl; msgData.ServerStartTime = ServerContext.StartTime; if (GeneralSettings.SettingsStore.ModControl) { msgData.ModFileData = FileHandler.ReadFileText(ServerContext.ModFilePath); } } MessageQueuer.SendToClient <HandshakeSrvMsg>(client, msgData); }
public static void SendHandshakeReply(ClientStructure client, HandshakeReply enumResponse, string reason) { var messageData = new HandshakeReplyMsgData { Response = enumResponse, Reason = reason }; if (enumResponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY) { messageData.ModControlMode = GeneralSettings.SettingsStore.ModControl; if (GeneralSettings.SettingsStore.ModControl != ModControlMode.DISABLED) { if (!FileHandler.FileExists(ServerContext.ModFilePath)) { ModFileSystem.GenerateNewModFile(); } messageData.ModFileData = FileHandler.ReadFile(ServerContext.ModFilePath); } } MessageQueuer.SendToClient <HandshakeSrvMsg>(client, messageData); }
private static void SendHandshakeReply(ClientObject client, HandshakeReply enumResponse, string reason) { ServerMessage newMessage = new ServerMessage(); newMessage.type = ServerMessageType.HANDSHAKE_REPLY; int response = (int)enumResponse; using (MessageWriter mw = new MessageWriter()) { mw.Write<int>(response); mw.Write<string>(reason); mw.Write<int>(Common.PROTOCOL_VERSION); mw.Write<string>(Common.PROGRAM_VERSION); if (response == 0) { mw.Write<int>((int)Settings.settingsStore.modControl); if (Settings.settingsStore.modControl != ModControlMode.DISABLED) { if (!File.Exists(Server.modFile)) { Server.GenerateNewModFile(); } string modFileData = File.ReadAllText(Server.modFile); mw.Write<string>(modFileData); } } newMessage.data = mw.GetMessageBytes(); } SendToClient(client, newMessage, true); }
public override void ConfigureServices(ServiceConfigurationContext context) { var netTestHelper = new NetworkTestContextHelpers(); context.Services.AddSingleton(netTestHelper); Configure <NetworkOptions>(o => { o.ListeningPort = 2001; o.MaxPeers = 2; }); context.Services.AddTransient(o => { var mockHandshakeProvider = new Mock <IHandshakeProvider>(); mockHandshakeProvider.Setup(h => h.GetHandshakeAsync()).ReturnsAsync(new Handshake()); return(mockHandshakeProvider.Object); }); context.Services.AddTransient(sp => { var mockDialer = new Mock <IPeerDialer>(); mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.FakeIpEndpoint))) .Returns <IPEndPoint>(s => { var peer = GrpcTestPeerHelpers.CreateBasicPeer(NetworkTestConstants.FakeIpEndpoint, NetworkTestConstants.FakePubkey); netTestHelper.AddDialedPeer(peer); return(Task.FromResult(peer)); }); mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.FakeIpEndpoint2))) .Returns <IPEndPoint>(s => { var peer = GrpcTestPeerHelpers.CreateBasicPeer(NetworkTestConstants.FakeIpEndpoint2, NetworkTestConstants.FakePubkey); netTestHelper.AddDialedPeer(peer); return(Task.FromResult(peer)); }); mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.DialExceptionIpEndpoint))) .Throws <PeerDialException>(); mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.HandshakeWithNetExceptionIp))) .Returns <IPEndPoint>(s => { var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)) .Throws(new AggregateException()); var peer = GrpcTestPeerHelpers.CreatePeerWithClient(NetworkTestConstants.FakeIpEndpoint2, NetworkTestConstants.FakePubkey, mockClient.Object); netTestHelper.AddDialedPeer(peer); return(Task.FromResult(peer)); }); // Incorrect handshake mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.BadHandshakeIp))) .Returns <IPEndPoint>((s) => { var handshakeReply = new HandshakeReply { Error = HandshakeError.InvalidHandshake, }; var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(handshakeCall); var peer = GrpcTestPeerHelpers.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint, NetworkTestConstants.FakePubkey, mockClient.Object); netTestHelper.AddDialedPeer(peer); return(Task.FromResult(peer)); }); // This peer will pass all checks with success. mockDialer.Setup(d => d.DialPeerAsync(It.Is <IPEndPoint>(ip => ip.ToString() == NetworkTestConstants.GoodPeerEndpoint))) .Returns <IPEndPoint>(s => { var keypair = CryptoHelper.GenerateKeyPair(); var handshakeReply = new HandshakeReply { Error = HandshakeError.HandshakeOk, Handshake = netTestHelper.CreateValidHandshake(keypair, 10) }; var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(handshakeCall); var peer = GrpcTestPeerHelpers.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint, keypair.PublicKey.ToHex(), mockClient.Object); netTestHelper.AddDialedPeer(peer); return(Task.FromResult(peer)); }); return(mockDialer.Object); }); }
public override void ConfigureServices(ServiceConfigurationContext context) { Configure <NetworkOptions>(o => { o.ListeningPort = 2001; o.MaxPeers = 2; }); context.Services.AddTransient(o => { var mockBlockchainService = new Mock <IBlockchainService>(); var keyPair = CryptoHelper.GenerateKeyPair(); mockBlockchainService.Setup(b => b.GetChainAsync()).ReturnsAsync(new Chain { Id = NetworkTestConstants.DefaultChainId }); mockBlockchainService.Setup(b => b.GetChainId()).Returns(NetworkTestConstants.DefaultChainId); mockBlockchainService.Setup(b => b.GetBlockHeaderByHashAsync(It.IsAny <Hash>())).ReturnsAsync( NetworkTestHelper.CreateFakeBlockHeader(NetworkTestConstants.DefaultChainId, 1, keyPair)); return(mockBlockchainService.Object); }); context.Services.AddTransient(sp => { var mockDialer = new Mock <IPeerDialer>(); mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants.FakeIpEndpoint))) .Returns <DnsEndPoint>(s => { var peer = GrpcTestPeerHelper.CreateBasicPeer(NetworkTestConstants.FakeIpEndpoint, NetworkTestConstants.FakePubkey); return(Task.FromResult(peer)); }); mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants.FakeIpEndpoint2))) .Returns <DnsEndPoint>(s => { var peer = GrpcTestPeerHelper.CreateBasicPeer(NetworkTestConstants.FakeIpEndpoint2, NetworkTestConstants.FakePubkey); return(Task.FromResult(peer)); }); mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants .DialExceptionIpEndpoint))) .Returns(Task.FromResult <GrpcPeer>(null)); mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants.HandshakeWithNetExceptionIp))) .Returns <DnsEndPoint>(s => { var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)) .Throws(new AggregateException()); var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.FakeIpEndpoint2, NetworkTestConstants.FakePubkey, mockClient.Object); return(Task.FromResult(peer)); }); // Incorrect handshake mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants.BadHandshakeIp))) .Returns <DnsEndPoint>((s) => { var handshakeReply = new HandshakeReply(); var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(handshakeCall); mockClient.Setup(m => m.ConfirmHandshakeAsync(It.IsAny <ConfirmHandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Throws(new AggregateException()); var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint, NetworkTestConstants.FakePubkey, mockClient.Object); return(Task.FromResult(peer)); }); // Incorrect handshake signature mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants .HandshakeWithDataExceptionIp))) .Returns <string>(async(s) => { var handshakeProvider = context.Services.GetServiceLazy <IHandshakeProvider>().Value; var handshake = await handshakeProvider.GetHandshakeAsync(); handshake.HandshakeData.Time = null; var handshakeReply = new HandshakeReply { Handshake = handshake }; var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(handshakeCall); var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint, NetworkTestConstants.FakePubkey, mockClient.Object); return(peer); }); // This peer will pass all checks with success. mockDialer.Setup(d => d.DialPeerAsync(It.Is <DnsEndPoint>(endPoint => endPoint.ToString() == NetworkTestConstants.GoodPeerEndpoint))) .Returns <DnsEndPoint>(s => { var keyPair = CryptoHelper.GenerateKeyPair(); var handshakeReply = new HandshakeReply { Handshake = NetworkTestHelper.CreateValidHandshake(keyPair, 10) }; var handshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(handshakeReply), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); var confirmHandshakeCall = TestCalls.AsyncUnaryCall(Task.FromResult(new VoidReply()), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { }); var mockClient = new Mock <PeerService.PeerServiceClient>(); mockClient.Setup(m => m.DoHandshakeAsync(It.IsAny <HandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(handshakeCall); mockClient.Setup(m => m.ConfirmHandshakeAsync(It.IsAny <ConfirmHandshakeRequest>(), It.IsAny <Metadata>(), It.IsAny <DateTime?>(), CancellationToken.None)).Returns(confirmHandshakeCall); var peer = GrpcTestPeerHelper.CreatePeerWithClient(NetworkTestConstants.GoodPeerEndpoint, NetworkTestConstants.FakePubkey, mockClient.Object); peer.UpdateLastSentHandshake(handshakeReply.Handshake); return(Task.FromResult(peer)); }); mockDialer.Setup(d => d.DialBackPeerAsync(It.IsAny <DnsEndPoint>(), It.IsAny <Handshake>())) .Returns <DnsEndPoint, Handshake>((endPoint, handshake) => { if (endPoint.ToString() == NetworkTestConstants.GoodPeerEndpoint) { var peer = GrpcTestPeerHelper.CreateBasicPeer(NetworkTestConstants.GoodPeerEndpoint, NetworkTestConstants.FakePubkey); return(Task.FromResult(peer)); } return(Task.FromResult <GrpcPeer>(null)); }); return(mockDialer.Object); }); }
public static void HandleHandshakeResponse(ClientObject client, byte[] messageData) { int protocolVersion; string playerName = ""; string playerPublicKey; byte[] playerChallangeSignature; string clientVersion = ""; string reason = ""; Regex regex = new Regex(@"[\""<>|$]"); // Regex to detect quotation marks, and other illegal characters //0 - Success HandshakeReply handshakeReponse = HandshakeReply.HANDSHOOK_SUCCESSFULLY; try { using (MessageReader mr = new MessageReader(messageData)) { protocolVersion = mr.Read <int>(); playerName = mr.Read <string>(); playerPublicKey = mr.Read <string>(); playerChallangeSignature = mr.Read <byte[]>(); clientVersion = mr.Read <string>(); try { client.compressionEnabled = mr.Read <bool>(); } catch { //This is safe to ignore. We want to tell people about version mismatches still. client.compressionEnabled = false; } } } catch (Exception e) { DarkLog.Debug("Error in HANDSHAKE_REQUEST from " + client.playerName + ": " + e); SendHandshakeReply(client, HandshakeReply.MALFORMED_HANDSHAKE, "Malformed handshake"); return; } if (regex.IsMatch(playerName)) { // Invalid username handshakeReponse = HandshakeReply.INVALID_PLAYERNAME; reason = "Invalid username"; } if (playerName.Contains("/") || playerName.Contains(@"\") || playerName.Contains("\n") || playerName.Contains("\r")) { handshakeReponse = HandshakeReply.INVALID_PLAYERNAME; reason = "Invalid username"; } if (protocolVersion != Common.PROTOCOL_VERSION) { //Protocol mismatch handshakeReponse = HandshakeReply.PROTOCOL_MISMATCH; reason = "Protocol mismatch"; } if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY) { //Check client isn't already connected ClientObject testClient = ClientHandler.GetClientByName(playerName); if (testClient != null) { Messages.Heartbeat.Send(testClient); Thread.Sleep(1000); } if (ClientHandler.ClientConnected(testClient)) { handshakeReponse = HandshakeReply.ALREADY_CONNECTED; reason = "Client already connected"; } } if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY) { bool reserveKick = false; //Check the client isn't using a reserved name if (playerName == "Initial") { reserveKick = true; } if (playerName == Settings.settingsStore.consoleIdentifier) { reserveKick = true; } if (reserveKick) { handshakeReponse = HandshakeReply.RESERVED_NAME; reason = "Kicked for using a reserved name"; } } if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY) { //Check the client matches any database entry string storedPlayerFile = Path.Combine(Server.universeDirectory, "Players", playerName + ".txt"); string storedPlayerPublicKey = ""; if (File.Exists(storedPlayerFile)) { storedPlayerPublicKey = File.ReadAllText(storedPlayerFile); if (playerPublicKey != storedPlayerPublicKey) { handshakeReponse = HandshakeReply.INVALID_KEY; reason = "Invalid key for user"; } else { using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(1024)) { rsa.PersistKeyInCsp = false; rsa.FromXmlString(playerPublicKey); bool result = rsa.VerifyData(client.challange, CryptoConfig.CreateFromName("SHA256"), playerChallangeSignature); if (!result) { handshakeReponse = HandshakeReply.INVALID_KEY; reason = "Public/private key mismatch"; } } } } else { try { File.WriteAllText(storedPlayerFile, playerPublicKey); DarkLog.Debug("Client " + playerName + " registered!"); } catch { handshakeReponse = HandshakeReply.INVALID_PLAYERNAME; reason = "Invalid username"; } } } client.playerName = playerName; client.publicKey = playerPublicKey; client.clientVersion = clientVersion; if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY) { if (BanSystem.fetch.IsPlayerNameBanned(client.playerName) || BanSystem.fetch.IsIPBanned(client.ipAddress) || BanSystem.fetch.IsPublicKeyBanned(client.publicKey)) { handshakeReponse = HandshakeReply.PLAYER_BANNED; reason = "You were banned from the server!"; } } if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY) { if (ClientHandler.GetActiveClientCount() >= Settings.settingsStore.maxPlayers) { handshakeReponse = HandshakeReply.SERVER_FULL; reason = "Server is full"; } } if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY) { if (Settings.settingsStore.whitelisted && !WhitelistSystem.fetch.IsWhitelisted(client.playerName)) { handshakeReponse = HandshakeReply.NOT_WHITELISTED; reason = "You are not on the whitelist"; } } if (handshakeReponse == HandshakeReply.HANDSHOOK_SUCCESSFULLY) { client.authenticated = true; string devClientVersion = ""; DMPPluginHandler.FireOnClientAuthenticated(client); if (client.clientVersion.Length == 40) { devClientVersion = client.clientVersion.Substring(0, 7); } else { devClientVersion = client.clientVersion; } DarkLog.Normal("Client " + playerName + " handshook successfully, version: " + devClientVersion); if (!Directory.Exists(Path.Combine(Server.universeDirectory, "Scenarios", client.playerName))) { Directory.CreateDirectory(Path.Combine(Server.universeDirectory, "Scenarios", client.playerName)); foreach (string file in Directory.GetFiles(Path.Combine(Server.universeDirectory, "Scenarios", "Initial"))) { File.Copy(file, Path.Combine(Server.universeDirectory, "Scenarios", playerName, Path.GetFileName(file))); } } SendHandshakeReply(client, handshakeReponse, "success"); Server.playerCount = ClientHandler.GetActiveClientCount(); Server.players = ClientHandler.GetActivePlayerNames(); DarkLog.Debug("Online players is now: " + Server.playerCount + ", connected: " + ClientHandler.GetClients().Length); } else { DarkLog.Normal("Client " + playerName + " failed to handshake: " + reason); SendHandshakeReply(client, handshakeReponse, reason); } }