private void SetEncryption(ExtendedSetEncryptionMessage message)
{
byte[] nonce = message.RemoveNonce();
int nonceMethod = message.GetNonceMethod();
if (nonceMethod == 1)
{
this.ScrambleNonceUsingMersenneTwister(nonce, nonce.Length);
}
else
{
this.ScrambleNonceUsingDefaultMethod(nonce, nonce.Length);
}
char[] nonceChars = new char[nonce.Length];
for (int i = 0; i < nonce.Length; i++)
{
nonceChars[i] = (char)nonce[i];
}
this.InitRC4Encryption(new string(nonceChars));
this.m_encryptionScrambled = true;
}
private int OnReceive(byte[] buffer, int length)
{
if (length >= Messaging.PACKET_HEADER_LENGTH)
{
Messaging.ReadHeader(buffer, out int messageType, out int messageLength, out int messageVersion);
if (length >= Messaging.PACKET_HEADER_LENGTH + messageLength)
{
byte[] encryptedBytes = new byte[messageLength];
byte[] encodingBytes;
Buffer.BlockCopy(buffer, Messaging.PACKET_HEADER_LENGTH, encryptedBytes, 0, messageLength);
int encodingLength;
if (this.m_receiveEncrypter != null)
{
encodingLength = messageLength - this.m_receiveEncrypter.GetOverheadEncryption();
encodingBytes = new byte[encodingLength];
this.m_receiveEncrypter.Decrypt(encryptedBytes, encodingBytes, encodingLength);
}
else
{
encodingLength = messageLength;
encodingBytes = encryptedBytes;
}
PiranhaMessage piranhaMessage = this.m_messageFactory.CreateMessageByType(messageType);
if (piranhaMessage != null)
{
piranhaMessage.SetMessageVersion(messageVersion);
piranhaMessage.GetByteStream().SetByteArray(encodingBytes, encodingLength);
piranhaMessage.Decode();
if (piranhaMessage.GetMessageType() != ExtendedSetEncryptionMessage.MESSAGE_TYPE)
{
this.m_receiveQueue.Enqueue(piranhaMessage);
}
else
{
ExtendedSetEncryptionMessage extendedSetEncryptionMessage = (ExtendedSetEncryptionMessage)piranhaMessage;
byte[] nonce = extendedSetEncryptionMessage.RemoveNonce();
switch (extendedSetEncryptionMessage.GetNonceMethod())
{
case 1:
this.ScrambleNonceUsingMersenneTwister(nonce);
break;
default:
this.ScrambleNonceUsingDefaultMethod(nonce);
break;
}
char[] nonceChars = new char[nonce.Length];
for (int i = 0; i < nonce.Length; i++)
{
nonceChars[i] = (char)nonce[i];
}
this.InitEncrypters(new string(nonceChars));
}
}
else
{
Debugger.Warning(string.Format("Messaging.onReceive: ignoring message of unknown type {0}", messageType));
}
return(Messaging.PACKET_HEADER_LENGTH + messageLength);
}
}
return(0);
}
/// <summary>
/// Called when the gateway receive a packet.
/// </summary>
internal int OnReceive(byte[] packet, int length)
{
if (length >= 7)
{
length -= 7;
int messageType = packet[1] | packet[0] << 8;
int messageLength = packet[4] | packet[3] << 8 | packet[2] << 16;
int messageVersion = packet[6] | packet[5] << 8;
if (length >= messageLength)
{
int encodingLength = messageLength;
byte[] encodingByteArray = new byte[messageLength];
Array.Copy(packet, 7, encodingByteArray, 0, messageLength);
if (this._receiveEncrypter != null)
{
byte[] encryptedByteArray = encodingByteArray;
byte[] decryptedByteArray = new byte[messageLength - this._receiveEncrypter.GetOverheadEncryption()];
this._receiveEncrypter.Decrypt(encryptedByteArray, decryptedByteArray, messageLength);
encodingByteArray = decryptedByteArray;
encodingLength -= this._receiveEncrypter.GetOverheadEncryption();
}
PiranhaMessage message = LogicMagicMessageFactory.Instance.CreateMessageByType(messageType);
if (message != null)
{
message.SetMessageVersion((short)messageVersion);
message.GetByteStream().SetByteArray(encodingByteArray, encodingLength);
try
{
message.Decode();
if (message.GetMessageType() == 20000)
{
ExtendedSetEncryptionMessage extendedSetEncryptionMessage = (ExtendedSetEncryptionMessage)message;
LogicMersenneTwisterRandom scrambler = new LogicMersenneTwisterRandom(0);
byte byte100 = 0;
for (int i = 0; i < 100; i++)
{
byte100 = (byte)scrambler.NextInt();
}
byte[] nonce = extendedSetEncryptionMessage.RemoveNonce();
string scrambledNonce = null;
for (int i = 0; i < nonce.Length; i++)
{
scrambledNonce += (char)(nonce[i] ^ (byte)(scrambler.NextInt() & byte100));
}
if (this._receiveEncrypter != null)
{
this._receiveEncrypter.Destruct();
this._receiveEncrypter = null;
}
if (this._sendEncrypter != null)
{
this._sendEncrypter.Destruct();
this._sendEncrypter = null;
}
this._receiveEncrypter = new RC4Encrypter(LogicMessagingConstants.RC4_KEY, scrambledNonce);
this._sendEncrypter = new RC4Encrypter(LogicMessagingConstants.RC4_KEY, scrambledNonce);
}
else
{
this.MessageManager.ReceiveMessage(message);
}
}
catch (Exception exception)
{
Logging.Error("Client::onReceive message decode exception, trace: " + exception);
}
Logging.Print("Client::sendMessage message " + message.GetType().Name + " received");
}
else
{
Logging.Warning("NetworkMessaging::onReceive Ignoring message of unknown type " + messageType);
}
return(messageLength + 7);
}
}
return(0);
}