public void TestMessagePutHeader()
{
Message message = new Message();
message.PutLong(long.MinValue);
Assert.AreEqual(8, message.ReadableBytes);
Assert.AreEqual(message.ReaderIndex + 8, message.WriterIndex);
var oldReaderIndex = message.ReaderIndex;
var oldWriterIndex = message.WriterIndex;
message.PutHeader((ushort)message.ReadableBytes);
Assert.AreEqual(10, message.ReadableBytes);
Assert.AreEqual(oldWriterIndex, message.WriterIndex);
Assert.AreEqual(oldReaderIndex - 2, message.ReaderIndex);
oldReaderIndex = message.ReaderIndex;
oldWriterIndex = message.WriterIndex;
message.PutHeader((uint)message.ReadableBytes);
Assert.AreEqual(14, message.ReadableBytes);
Assert.AreEqual(oldWriterIndex, message.WriterIndex);
Assert.AreEqual(oldReaderIndex - 4, message.ReaderIndex);
}
public override void OnReceiveFirstMessage(Message message)
{
message.GetUShort(); //OS
var version = message.GetUShort();
Rsa.Decrypt(message);
uint[] key = new uint[4];
key[0] = message.GetUInt();
key[1] = message.GetUInt();
key[2] = message.GetUInt();
key[3] = message.GetUInt();
XteaKey = key;
HasXteaEncryption = true;
var isGm = message.GetBool();
var accountName = message.GetString();
var playerName = message.GetString();
var password = message.GetString();
message.ReaderIndex += 6;
if (version != Constants.ClientVersionNumber)
{
Disconnect(0x0A, "This server requires client version " + Constants.ClientVersion + ".");
return;
}
Disconnect(0x14, "Under construction.");
}
public static unsafe void Encrypt(Message message, uint[] key)
{
var pad = message.ReadableBytes % 8;
if (pad > 0)
message.WriterIndex += (8 - pad);
var msgSize = message.ReadableBytes;
fixed (byte* bufferPtr = message.Buffer) {
var words = (uint*)(bufferPtr + message.ReaderIndex);
for (var pos = 0; pos < msgSize / 4; pos += 2) {
uint sum = 0;
uint count = 32;
while (count-- > 0) {
words [pos] += (words [pos + 1] << 4 ^ words [pos + 1] >> 5) + words [pos + 1] ^ sum
+ key [sum & 3];
sum += Constants.XteaDelta;
words [pos + 1] += (words [pos] << 4 ^ words [pos] >> 5) + words [pos] ^ sum
+ key [sum >> 11 & 3];
}
}
}
}
public virtual void OnReceiveMessage(Message message)
{
if (_hasChecksum && message.GetUInt() != Adler.Generate(message))
throw new Exception("Invalid message checksum.");
if (_hasXteaEncryption)
{
Xtea.Decrypt(message, _xteaKey);
var length = message.GetUShort();
message.WriterIndex = message.ReaderIndex + length;
}
}
public void Put(Message message)
{
if (message == null)
throw new ArgumentNullException("message");
lock (_messages)
{
if (_messages.Count < _maxSize)
_messages.Push(message);
else
Dispose(message);
}
}
public void TestMessagePutGet()
{
Message message = new Message();
Assert.AreEqual(0, message.ReadableBytes);
message.PutByte(byte.MaxValue);
message.PutByte(byte.MinValue);
message.PutUShort(ushort.MaxValue);
message.PutUShort(ushort.MinValue);
message.PutShort(short.MaxValue);
message.PutShort(short.MinValue);
message.PutUInt(uint.MaxValue);
message.PutUInt(uint.MinValue);
message.PutInt(int.MaxValue);
message.PutInt(int.MinValue);
message.PutULong(ulong.MaxValue);
message.PutULong(ulong.MinValue);
message.PutLong(long.MaxValue);
message.PutLong(long.MinValue);
message.PutString(string.Empty);
message.PutString("123");
Assert.AreEqual(65, message.ReadableBytes);
Assert.AreEqual(byte.MaxValue, message.GetByte());
Assert.AreEqual(byte.MinValue, message.GetByte());
Assert.AreEqual(ushort.MaxValue, message.GetUShort());
Assert.AreEqual(ushort.MinValue, message.GetUShort());
Assert.AreEqual(short.MaxValue, message.GetShort());
Assert.AreEqual(short.MinValue, message.GetShort());
Assert.AreEqual(uint.MaxValue, message.GetUInt());
Assert.AreEqual(uint.MinValue, message.GetUInt());
Assert.AreEqual(int.MaxValue, message.GetInt());
Assert.AreEqual(int.MinValue, message.GetInt());
Assert.AreEqual(ulong.MaxValue, message.GetULong());
Assert.AreEqual(ulong.MinValue, message.GetULong());
Assert.AreEqual(long.MaxValue, message.GetLong());
Assert.AreEqual(long.MinValue, message.GetLong());
Assert.AreEqual(string.Empty, message.GetString());
Assert.AreEqual("123", message.GetString());
Assert.AreEqual(0, message.ReadableBytes);
}
public void TestAdlerGenerate()
{
Message message = new Message();
message.PutULong(ulong.MaxValue);
var checksum = Adler.Generate(message);
Xtea.Encrypt(message, _key);
Assert.AreNotEqual(checksum, Adler.Generate(message));
Xtea.Decrypt(message, _key);
Assert.AreEqual(checksum, Adler.Generate(message));
}
public static uint Generate(Message message)
{
if (message.ReadableBytes <= 0)
throw new InvalidOperationException("Invalid message length.");
var end = message.WriterIndex;
var start = message.ReaderIndex;
var buffer = message.Buffer;
var unSum1 = Constants.AdlerChecksumStart & 0xFFFF;
var unSum2 = (Constants.AdlerChecksumStart >> 16) & 0xFFFF;
for (var i = start; i < end; i++)
{
unSum1 = (unSum1 + buffer[i]) % Constants.AdlerChecksumBase;
unSum2 = (unSum1 + unSum2) % Constants.AdlerChecksumBase;
}
return (unSum2 << 16) + unSum1;
}
public void TestXteaEncryptDecrypt()
{
Message message = new Message();
message.PutUInt(uint.MaxValue);
message.PutShort(short.MinValue);
Xtea.Encrypt(message, _key);
Assert.AreEqual(8, message.ReadableBytes);
message.MarkReaderIndex();
Assert.AreNotEqual(uint.MaxValue, message.GetUInt());
Assert.AreNotEqual(short.MinValue, message.GetShort());
message.ResetReaderIndex();
Xtea.Decrypt(message, _key);
Assert.AreEqual(uint.MaxValue, message.GetUInt());
Assert.AreEqual(short.MinValue, message.GetShort());
}
public Connection(Server server, ServicePort servicePort, Socket socket)
{
if (server == null)
throw new ArgumentNullException("server");
if(servicePort == null)
throw new ArgumentNullException("servicePort");
if (socket == null)
throw new ArgumentNullException("socket");
if (!socket.Connected)
throw new ArgumentException("The socket is not connected.");
_server = server;
_servicePort = servicePort;
_socket = socket;
_message = new Message(true);
_sendLock = new object();
_sendEventArgs = new SocketAsyncEventArgs();
_sendEventArgs.Completed += SendCallback;
_remoteAddress = ((IPEndPoint)_socket.RemoteEndPoint).Address.ToString();
_ipAddress = IPConverter.ToUInt32(_remoteAddress);
}
public static unsafe void Decrypt(Message message, uint[] key)
{
var msgSize = message.ReadableBytes;
if (msgSize % 8 > 0)
throw new Exception("Invalid Xtea encrypted message size.");
fixed (byte* bufferPtr = message.Buffer) {
var words = (uint*)(bufferPtr + message.ReaderIndex);
for (var pos = 0; pos < msgSize / 4; pos += 2) {
var count = 32;
var sum = 0xC6EF3720;
while (count-- > 0) {
words [pos + 1] -= (words [pos] << 4 ^ words [pos] >> 5) + words [pos] ^ sum
+ key [sum >> 11 & 3];
sum -= Constants.XteaDelta;
words [pos] -= (words [pos + 1] << 4 ^ words [pos + 1] >> 5) + words [pos + 1] ^ sum
+ key [sum & 3];
}
}
}
}
public virtual void OnReceiveFirstMessage(Message message)
{
}
protected Message GetOutputBuffer()
{
if (_outputBuffer != null && _outputBuffer.ReadableBytes < Constants.MessageDefaultSize - 4096)
return _outputBuffer;
else if (_connection != null)
{
_outputBuffer = _server.OutputMessagePool.Get(_connection, true);
return _outputBuffer;
}
return null;
}
public override void OnReceiveFirstMessage(Message message)
{
message.GetUShort();
var version = message.GetUShort();
message.ReaderIndex += 12;
Rsa.Decrypt(message);
uint[] key = new uint[4];
key[0] = message.GetUInt();
key[1] = message.GetUInt();
key[2] = message.GetUInt();
key[3] = message.GetUInt();
XteaKey = key;
HasXteaEncryption = true;
if (version != Constants.ClientVersionNumber)
{
Disconnect(0x0A, "This server requires client version " + Constants.ClientVersion + ".");
return;
}
var login = message.GetString();
var password = message.GetString();
if (login.Length < 5)
{
Disconnect(0x0A, "Invalid Account Name.");
return;
}
var account = Server.Instance.AccountRepository.Load(login);
if (account == null)
{
Disconnect(0x0A, "Account name or password is not correct.");
return;
}
var output = Server.OutputMessagePool.Get(Connection, false);
if (output != null)
{
var serverIp = Server.ServiceManager.IpAddresses.First().Key;
foreach (var keyPair in Server.ServiceManager.IpAddresses)
{
if ((keyPair.Key & keyPair.Value) == (Connection.IpAddress & keyPair.Value))
{
serverIp = keyPair.Key;
break;
}
}
output.PutByte(0x64);
output.PutByte((byte)account.Characters.Count);
foreach (var character in account.Characters)
{
output.PutString(character);
output.PutString(Server.ConfigManager.WorldName);
output.PutUInt(serverIp);
output.PutUShort((ushort)Server.ConfigManager.GamePort);
}
output.PutUShort(account.PremiumDaysLeft);
Connection.Write(output);
}
Connection.Close();
}
protected virtual void OnSendMessage(Message message)
{
try
{
if (_protocol != null)
_protocol.OnSendMessage(message);
}
catch (Exception e)
{
OnExceptionCaught(e);
}
}
public void Write(Message message)
{
OnSendMessage(message);
lock (_sendLock)
{
_pendingSend++;
if (_sending)
{
_server.OutputMessagePool.PutSend(message);
return;
}
if (_sendTimeout > 0)
_sendTimeoutScheduleId = _server.Scheduler.Add(_sendTimeout, OnMessageSendTimeout);
_sendEventArgs.SetBuffer(message.Buffer, message.ReaderIndex, message.ReadableBytes);
_sendEventArgs.UserToken = message;
_sending = true;
_socket.SendAsync(_sendEventArgs);
}
}
private void Dispose(Message value)
{
if (value != null)
_count--;
}
public void TestMessageReadOnly()
{
Message message = new Message(true);
Assert.IsTrue(message.IsReadyOnly);
message.PutByte(byte.MaxValue);
}
public virtual void OnSendMessage(Message message)
{
message.PutHeader((ushort)message.ReadableBytes);
if (_hasXteaEncryption && _xteaKey != null)
Xtea.Encrypt(message, _xteaKey);
if (_hasChecksum)
message.PutHeader(Adler.Generate(message));
if (_hasXteaEncryption || _hasChecksum)
message.PutHeader((ushort)message.ReadableBytes);
}
public void PutSend(Message message)
{
if (message == null)
throw new ArgumentNullException("message");
lock (_autoSendMessages)
_autoSendMessages.Add(message);
}
//public static void Encrypt(Message message)
//{
// var encryptedBytes = EncryptRsaEngine.ProcessBlock(message.Buffer, message.ReaderIndex, 128);
// Array.Copy(encryptedBytes, 0, message.Buffer, offset, length);
//}
public static void Decrypt(Message message)
{
var decryptedBytes = DecryptRsaEngine.ProcessBlock(message.Buffer, message.ReaderIndex, 128);
Array.Copy(decryptedBytes, 0, message.Buffer, message.ReaderIndex, decryptedBytes.Length);
}
private Message Configure(Message message, Connection connection, bool autoSend)
{
if (autoSend)
{
lock (_autoSendMessages)
_autoSendMessages.Add(message);
}
message.Clear();
message.Connection = connection;
message.FrameTime = _frameTime;
return message;
}