public void CompressedMessage(IService service, CompressedMessage message, MessageReceivedEventArgs e) { var decompressed = message.Data.DecompressZLib(); ProudCoreOpCode opCode; byte[] data; using (var r = decompressed.ToBinaryReader()) { opCode = r.ReadEnum <ProudCoreOpCode>(); data = r.ReadToEnd(); } switch (opCode) { case ProudCoreOpCode.Rmi: var rmi = new RmiMessage(data) { IsRelayed = message.IsRelayed, SenderHostId = message.SenderHostId, TargetHostId = message.TargetHostId }; e.Message = rmi; _filter.OnMessageReceived(e); break; default: throw new ProudException("Invalid opCode inside CompressedMessage: " + opCode); } }
public void RmiMessage(ProudSession session, RmiMessage message, MessageReceivedEventArgs e) { var rmiId = BitConverter.ToUInt16(message.Data, 0); if (rmiId >= 60000) { using (var r = message.Data.ToBinaryReader()) { var opCode = r.ReadEnum <ProudOpCode>(); var proudMessage = ProudMapper.GetMessage(opCode, r); if (!r.IsEOF()) #if DEBUG { r.BaseStream.Position = 0; throw new ProudBadFormatException(proudMessage.GetType(), r.ReadToEnd()); } #else { throw new ProudBadFormatException(proudMessage.GetType()); } #endif e.Message = proudMessage; OnProudMessageReceived(e); } return; } e.Message = new ProudRmiMessage(message.Data); _filter.NextOnMessageReceived(e); }
internal Task ProcessAndSendMessage(MessageEventArgs e, EncryptContext context) { var message = (ProudMessage)e.Message; var data = message.ToArray(); CoreMessage coreMessage = new RmiMessage(data); if (message.Compress) { data = coreMessage.ToArray(); coreMessage = new CompressedMessage(data.Length, data.CompressZLib()); } if (message.Encrypt) { data = coreMessage.ToArray(); using (var w = new PooledMemoryStream(Service.ArrayPool).ToBinaryWriter(false)) { w.Write(context.EncryptCounter); w.Write(data); data = w.ToArray(); } data = context.Encrypt(data); coreMessage = new EncryptedReliableMessage(data); } e.Message = coreMessage; return(base.OnSendMessage(e)); }
public void RmiMessage(IChannelHandlerContext context, RmiMessage message, RecvContext recvContext) { var buffer = Unpooled.WrappedBuffer(message.Data); recvContext.Message = buffer; context.FireChannelRead(recvContext); }
public override void ChannelActive(IChannelHandlerContext context) { base.ChannelActive(context); RmiMessage firstMessage = new RmiMessage(); firstMessage.Write(MessageType.Notify); firstMessage.Write("<region>EU-S4L</region>"); SendA(context, firstMessage); }
public void UnreliableRelayHandler(ProudSession session, UnreliableRelay1Message message, MessageReceivedEventArgs e) { foreach (var destination in message.Destination.Where(id => id != session.HostId)) { if (session.P2PGroup == null) { Logger.Debug() .Message("Client {0} in not a p2pgroup", session.HostId) .Write(); return; } if (!session.P2PGroup.Members.ContainsKey(destination)) { Logger.Debug() .Message("Client {0} trying to relay to non existant {1}", session.HostId, destination) .Write(); return; } if (destination == 2) { #region Hardcoded ServerMember ProudCoreOpCode opCode; byte[] data; using (var r = message.Data.ToBinaryReader()) { opCode = r.ReadEnum <ProudCoreOpCode>(); data = r.ReadToEnd(); } if (opCode == ProudCoreOpCode.Rmi) { var core = new RmiMessage(data) { IsRelayed = true, SenderHostId = session.HostId, TargetHostId = destination }; e.Message = core; _filter.OnMessageReceived(e); } else { throw new ProudException($"Invalid opCode {opCode}"); } #endregion } else { var target = _filter.SessionLookupByHostId.GetValueOrDefault(destination); target?.Send(new UnreliableRelay2Message(session.HostId, message.Data)); } } }
public void RmiSend(IChannelHandlerContext ctx, short RmiID, RmiMessage message) { RmiMessage rmiframe = new RmiMessage(); rmiframe.Write(MessageType.Rmi); rmiframe.Write(RmiID); rmiframe.Write(message); SendA(ctx, rmiframe); }
protected override void Encode(IChannelHandlerContext context, SendContext message, List <object> output) { var buffer = message.Message as IByteBuffer; if (buffer == null) { throw new ProudException($"{nameof(SendContextEncoder)} can only handle {nameof(IByteBuffer)}"); } try { var data = buffer.ToArray(); ICoreMessage coreMessage = new RmiMessage(data); var session = context.Channel.GetAttribute(ChannelAttributes.Session).Get(); if (session == null) { return; } var server = context.Channel.GetAttribute(ChannelAttributes.Server).Get(); if (data.Length > server.Configuration.MessageMaxLength) { throw new ProudException("Message is longer than max messagelength!"); } //else if (data.Length > server.Configuration.MaxUncompressedMessageLength && // coreMessage.GetType() != typeof(CompressedMessage)) // message.SendOptions.Compress = true; if (message.SendOptions.Compress) { data = CoreMessageEncoder.Encode(coreMessage); coreMessage = new CompressedMessage(data.Length, data.CompressZLib()); } if (message.SendOptions.Encrypt) { data = CoreMessageEncoder.Encode(coreMessage); using (var src = new MemoryStream(data)) using (var dst = new MemoryStream()) { session.Crypt?.Encrypt(context.Allocator, EncryptMode.Secure, src, dst, true); data = dst.ToArray(); } coreMessage = new EncryptedReliableMessage(data, EncryptMode.Secure); } output.Add(coreMessage); } finally { buffer.Release(); } }
public void RmiMessage(IChannelHandlerContext context, RmiMessage message) { var buffer = Unpooled.WrappedBuffer(message.Data); try { context.FireChannelRead(buffer); } catch (Exception e) // TODO: What is this try/catch? { } }
public void SendA(IChannelHandlerContext ctx, RmiMessage data) { RmiMessage coreframe = new RmiMessage(); coreframe.Write(Magic); coreframe.WriteScalar(data.Length); coreframe.Write(data); IByteBuffer buffer = Unpooled.Buffer(coreframe.Length); buffer.WriteBytes(coreframe.Buffer); ctx.WriteAndFlushAsync(buffer); }
protected override void Encode(IChannelHandlerContext context, SendContext message, List <object> output) { if (!(message.Message is IByteBuffer buffer)) { throw new ProudException($"{nameof(SendContextEncoder)} can only handle {nameof(IByteBuffer)}"); } try { var data = buffer.GetIoBuffer().ToArray(); ICoreMessage coreMessage = new RmiMessage(data); if (message.SendOptions.RelayFrom > 0) { data = CoreMessageEncoder.Encode(_serializer, coreMessage); coreMessage = new UnreliableRelay2Message(message.SendOptions.RelayFrom, data); } else { if (message.SendOptions.Compress) { data = CoreMessageEncoder.Encode(_serializer, coreMessage); coreMessage = new CompressedMessage(data.Length, data.CompressZLib()); } if (message.SendOptions.Encrypt) { data = CoreMessageEncoder.Encode(_serializer, coreMessage); var session = context.Channel.GetAttribute(ChannelAttributes.Session).Get(); using (var src = new MemoryStream(data)) using (var dst = new MemoryStream()) { session.Crypt.Encrypt(context.Allocator, EncryptMode.Secure, src, dst, true); data = dst.ToArray(); } coreMessage = new EncryptedReliableMessage(data, EncryptMode.Secure); } } output.Add(coreMessage); } finally { buffer.Release(); } }
protected override void Encode(IChannelHandlerContext context, SendContext message, List <object> output) { var buffer = message.Message as IByteBuffer; if (buffer == null) { throw new ProudException($"{nameof(SendContextEncoder)} can only handle {nameof(IByteBuffer)}"); } try { var data = buffer.ToArray(); ICoreMessage coreMessage = new RmiMessage(data); if (message.SendOptions.Compress) { data = CoreMessageEncoder.Encode(coreMessage); coreMessage = new CompressedMessage(data.Length, data.CompressZLib()); } if (message.SendOptions.Encrypt) { data = CoreMessageEncoder.Encode(coreMessage); var session = context.Channel.GetAttribute(ChannelAttributes.Session).Get(); using (var src = new MemoryStream(data)) using (var dst = new MemoryStream()) { session.Crypt.Encrypt(src, dst, true); data = dst.ToArray(); } coreMessage = new EncryptedReliableMessage(data); } output.Add(coreMessage); } finally { buffer.Release(); } }
public void EncryptedReliableMessage(ProudSession session, EncryptedReliableMessage message, MessageReceivedEventArgs e) { EncryptContext encryptContext; if (message.IsRelayed) { var remotePeer = (ServerRemotePeer)session.P2PGroup?.Members.GetValueOrDefault(message.TargetHostId); if (remotePeer == null) { return; } encryptContext = remotePeer.EncryptContext; if (encryptContext == null) { throw new ProudException($"Received encrypted message but the remote peer has no encryption enabled"); } } else { encryptContext = session.EncryptContext; } var decrypted = encryptContext.Decrypt(message.Data); ushort decryptCounter; byte[] data; using (var r = decrypted.ToBinaryReader()) { decryptCounter = r.ReadUInt16(); data = r.ReadToEnd(); } if (decryptCounter != (session.EncryptContext.DecryptCounter - 1)) { throw new ProudException($"Invalid DecryptCounter! Message: {decryptCounter} Client: {session.EncryptContext.DecryptCounter}"); } ProudCoreOpCode opCode; using (var r = data.ToBinaryReader()) { opCode = r.ReadEnum <ProudCoreOpCode>(); data = r.ReadToEnd(); } switch (opCode) { case ProudCoreOpCode.Rmi: var rmi = new RmiMessage(data) { IsRelayed = message.IsRelayed, SenderHostId = message.SenderHostId, TargetHostId = message.TargetHostId }; e.Message = rmi; _filter.OnMessageReceived(e); break; case ProudCoreOpCode.Compressed: CompressedMessage compressed; using (var r = data.ToBinaryReader()) compressed = Serializer.Deserialize <CompressedMessage>(r); compressed.IsRelayed = message.IsRelayed; compressed.SenderHostId = message.SenderHostId; compressed.TargetHostId = message.TargetHostId; e.Message = compressed; _filter.OnMessageReceived(e); break; default: throw new ProudException("Invalid opCode inside EncryptedMessage: " + opCode); } }
public void ReliableRelayHandler(ProudSession session, ReliableRelay1Message message, MessageReceivedEventArgs e) { if (session.P2PGroup == null) { return; } foreach (var destination in message.Destination.Where(d => d.HostId != session.HostId)) { if (session.P2PGroup == null) { Logger.Debug($"Client {session.HostId} is not in a P2PGroup"); return; } if (!session.P2PGroup.Members.ContainsKey(destination.HostId)) { Logger.Debug($"Client {session.HostId} trying to relay to non existant {destination.HostId}"); return; } if (destination.HostId == 2) { #region Hardcoded ServerMember ProudCoreOpCode opCode; byte[] data; using (var r = message.Data.ToBinaryReader()) { opCode = r.ReadEnum <ProudCoreOpCode>(); data = r.ReadToEnd(); } if (opCode == ProudCoreOpCode.Rmi) { var core = new RmiMessage(data) { IsRelayed = true, SenderHostId = session.HostId, TargetHostId = destination.HostId }; e.Message = core; _filter.OnMessageReceived(e); } else if (opCode == ProudCoreOpCode.ReliableUdp_Frame) { ReliableUdp_FrameMessage udpFrameMessage; using (var r = data.ToBinaryReader()) udpFrameMessage = Serializer.Deserialize <ReliableUdp_FrameMessage>(r); using (var r = udpFrameMessage.Data.ToBinaryReader()) { opCode = r.ReadEnum <ProudCoreOpCode>(); data = r.ReadToEnd(); } CoreMessage core; if (opCode == ProudCoreOpCode.Rmi) { core = new RmiMessage(data) { IsRelayed = true, SenderHostId = session.HostId, TargetHostId = destination.HostId }; } else if (opCode == ProudCoreOpCode.EncryptedReliable) { using (var r = data.ToBinaryReader()) core = Serializer.Deserialize <EncryptedReliableMessage>(r); core.IsRelayed = true; core.SenderHostId = session.HostId; core.TargetHostId = destination.HostId; } else { throw new ProudException($"Invalid opCode {opCode}"); } e.Message = core; _filter.OnMessageReceived(e); } else { throw new ProudException($"Invalid opCode {opCode}"); } #endregion } else { var target = _filter.SessionLookupByHostId.GetValueOrDefault(destination.HostId); target?.Send(new ReliableRelay2Message(new RelayDestinationDto(session.HostId, destination.FrameNumber), message.Data)); } } }
public void RmiMessage(IChannelHandlerContext context, RmiMessage message) { var buffer = Unpooled.WrappedBuffer(message.Data); context.FireChannelRead(buffer); }
internal void Write(RmiMessage obj) { Write(obj._buffer); }
public override void ChannelRead(IChannelHandlerContext context, object messageData) { var buffer = messageData as IByteBuffer; byte[] data = buffer.ToArray(); RmiMessage __msg = new RmiMessage(data, data.Length); short magic = 0; ByteArray _message = new ByteArray(); if (__msg.Read(ref magic) && magic == Magic && __msg.Read(ref _message)) { RmiMessage message = new RmiMessage(_message); MessageType coreID = 0; if (message.Read(ref coreID)) { switch (coreID) { case MessageType.Rmi: { short RmiID = 0; if (message.Read(ref RmiID)) { switch (RmiID) { case 15: { AccountDto account; string Username = ""; string Password = ""; bool register = false; if (message.Read(ref Username) && message.Read(ref Password) && message.Read(ref register)) { using (var db = AuthDatabase.Open()) { Logger.Information("Authentication login from {endpoint}", context.Channel.RemoteAddress.ToString()); if (Username.Length > 5 && Password.Length > 5) { var result = db.Find <AccountDto>(statement => statement .Where($"{nameof(AccountDto.Username):C} = @{nameof(Username)}") .Include <BanDto>(join => join.LeftOuterJoin()) .WithParameters(new { Username })); account = result.FirstOrDefault(); if (account == null) { account = new AccountDto { Username = Username }; var newSalt = new byte[24]; using (var csprng = new RNGCryptoServiceProvider()) csprng.GetBytes(newSalt); var hash = new byte[24]; using (var pbkdf2 = new Rfc2898DeriveBytes(Password, newSalt, 24000)) hash = pbkdf2.GetBytes(24); account.Password = Convert.ToBase64String(hash); account.Salt = Convert.ToBase64String(newSalt); db.InsertAsync(account); } var salt = Convert.FromBase64String(account.Salt); var passwordGuess = new byte[24]; using (var pbkdf2 = new Rfc2898DeriveBytes(Password, salt, 24000)) passwordGuess = pbkdf2.GetBytes(24); var actualPassword = Convert.FromBase64String(account.Password); uint difference = (uint)passwordGuess.Length ^ (uint)actualPassword.Length; for (var i = 0; i < passwordGuess.Length && i < actualPassword.Length; i++) { difference |= (uint)(passwordGuess[i] ^ actualPassword[i]); } if (difference != 0 || string.IsNullOrWhiteSpace(account.Password)) { Logger.Error("Wrong authentication credentials for {username} / {endpoint}", Username, context.Channel.RemoteAddress.ToString()); RmiMessage ack = new RmiMessage(); ack.Write(false); ack.Write("Login failed"); RmiSend(context, 16, ack); } else { account.LoginToken = AuthHash.GetHash256($"{context.Channel.RemoteAddress.ToString()}-{account.Username}-{account.Password}").ToLower(); account.LastLogin = $"{DateTimeOffset.Now}"; account.AuthToken = ""; account.newToken = ""; db.UpdateAsync(account); RmiMessage ack = new RmiMessage(); ack.Write(true); ack.Write(account.LoginToken); RmiSend(context, 16, ack); Logger.Information("Authentication success for {username}", Username); } } else { Logger.Error("Wrong authentication credentials for {username} / {endpoint}", Username, context.Channel.RemoteAddress.ToString()); RmiMessage ack = new RmiMessage(); ack.Write(false); ack.Write("Invalid length of username/password"); RmiSend(context, 16, ack); } } } else { Logger.Error("Wrong login for {endpoint}", context.Channel.RemoteAddress.ToString()); RmiMessage ack = new RmiMessage(); ack.Write(false); ack.Write("Invalid loginpacket"); RmiSend(context, 16, ack); } break; } case 17: context.CloseAsync(); break; default: Logger.Error("Received unknown rmiID{rmi} from {endpoint}", RmiID, context.Channel.RemoteAddress.ToString()); break; } } break; } case MessageType.Notify: { string info = ""; message.Read(ref info); Logger.Information("Received info! -> {received}", info); break; } default: Logger.Error("Received unknown coreID{coreid} from {endpoint}", coreID, context.Channel.RemoteAddress.ToString()); break; } } } else { Logger.Error("Received invalid packetstruct from {endpoint}", context.Channel.RemoteAddress.ToString()); context.CloseAsync(); } }