internal SSPError SendUdpMessage(IMessage message, UdpPAcketId packetId)
{
lock (UdpHandle)
{
PayloadWriter pw = new PayloadWriter();
pw.WriteDecimal(this.ClientId);
pw.WriteByte((byte)packetId);
pw.WriteUInteger(Connection.messageHandler.GetMessageId(message.GetType()));
message.WritePacket(message, ref pw);
this.UdpHandle.SendTo(pw.GetBuffer(), 0, pw.Length, SocketFlags.None, this.UdpEndPoint);
return(SSPError.ErrorSuccess);
}
}
private static void SaveMaskTable(ref List <double> Digits, ref DataShuffler dataShuffler, int ByteIndex, ref Stream OutStream)
{
if (Digits.Count == 0)
{
return;
}
Console.WriteLine("Digits:" + Digits.Count);
PayloadWriter pw = new PayloadWriter();
double[] Shuffled = dataShuffler.Shuffle <double>(Digits.ToArray(), 1, (double progress, TimeSpan TimeLeft, int speed) =>
{
if ((int)progress % 5 == 0.0F)
{
Console.WriteLine("Shuffle progress:" + progress + ", Speed: " + speed + ", Time Left: " + TimeLeft.Hours.ToString("D2") + ":" + TimeLeft.Minutes.ToString("D2") + ":" + TimeLeft.Seconds.ToString("D2"));
}
});
for (int k = 0; k < Shuffled.Length; k++)
{
int Target = (int)Shuffled[k];
pw.WriteByte((byte)ByteIndex); //byte length
if (ByteIndex >= 1 || ByteIndex <= 3) //play it safe
{
pw.WriteUInteger((uint)Target);
}
else
{
pw.WriteDecimal(Target);
}
if (pw.Length >= 65535)
{
OutStream.Write(pw.GetBuffer(), 0, pw.Length);
OutStream.Flush();
pw = new PayloadWriter();
}
}
if (pw.Length > 0)
{
OutStream.Write(pw.GetBuffer(), 0, pw.Length);
OutStream.Flush();
}
pw.Dispose();
Digits.Clear();
}
public void WriteDnsFile(string FilePath)
{
if (!File.Exists(FilePath))
{
File.Create(FilePath).Close();
}
PayloadWriter pw = new PayloadWriter();
for (int i = 0; i < DnsNames.Count; i++)
{
pw.WriteString(DnsNames.Values[i].DnsName);
pw.WriteUInteger(DnsNames.Values[i].DnsId);
}
File.WriteAllBytes(FilePath, pw.ToByteArray());
}
public ClientProperties(string HostIp, ushort Port, Type BaseChannel, object[] BaseChannelArgs, byte[] PrivateKey, Stream[] KeyFiles = null,
ProxySettings proxySettings = null, int ConnectingTimeout = 30000, string Username = "", string Password = "",
bool AllowChannels = true, bool AllowPeers = true)
{
this.HostIp = HostIp;
this.Port = Port;
this.BaseChannel = BaseChannel;
this.BaseChannelArgs = BaseChannelArgs;
this.proxySettings = proxySettings;
this.ConnectingTimeout = ConnectingTimeout;
this.PrivateKey = PrivateKey;
this.Username = Username;
this.KeyFiles = KeyFiles;
this.AllowChannels = AllowChannels;
this.AllowPeers = AllowPeers;
if (Password != null && Password.Length > 0)
{
byte[] basePass = ASCIIEncoding.ASCII.GetBytes(Convert.ToBase64String(ASCIIEncoding.Unicode.GetBytes(Password)));
PayloadWriter keyPW = new PayloadWriter();
keyPW.WriteUInteger(new MurmurHash2Unsafe().Hash(BitConverter.GetBytes(new SuperFastHashUInt16Hack().Hash(basePass))));
keyPW.WriteUInteger(new MurmurHash2Unsafe().Hash(BitConverter.GetBytes(new MurmurHash2Simple().Hash(basePass))));
keyPW.WriteUInteger(new SuperFastHashInlineBitConverter().Hash(BitConverter.GetBytes(new SuperFastHashUInt16Hack().Hash(basePass))));
keyPW.WriteBytes(SHA512Managed.Create().ComputeHash(keyPW.ToByteArray()));
byte[] key = keyPW.ToByteArray();
unsafe
{
fixed(byte *x = basePass)
{
for (int i = 0; i < basePass.Length; i++)
{
x[i] += (byte)((x[i] ^ key[i % key.Length]) % 0xFF);
x[i] ^= (byte)((x[(i + 1) % basePass.Length] / 2) * key[i % key.Length]);
x[i] ^= (byte)Password[i % Password.Length];
}
}
}
//generate random bytes at the end based on the hash
PayloadWriter Out = new PayloadWriter();
Out.WriteBytes(basePass);
byte[] GenKey = new byte[32];
for (int i = 0; i < GenKey.Length; i++)
{
GenKey[i] = (byte)((basePass[i % basePass.Length] + key[i % key.Length]) % 0xFF);
if ((GenKey[((i * 2) / 3) % GenKey.Length] ^ (byte)(key[i % key.Length] ^ GenKey[i])) > 0)
{
GenKey[((i * 2) / 3) % GenKey.Length] ^= (byte)(key[i % key.Length] ^ GenKey[i]);
}
else
{
GenKey[(i * 3) % GenKey.Length] ^= (byte)((basePass[i % basePass.Length] << 8) % 0xFF);
}
}
Out.WriteBytes(GenKey);
this.Password = BitConverter.ToString(Out.ToByteArray()).Replace("-", "");
}
Password = ""; //remove from memory hopefully
}
/// <summary>
/// Send data to the established connection
/// </summary>
/// <param name="Message">The data to send</param>
/// <param name="Header">The Header to use for adding additional information</param>
/// <param name="feature">The Feature that has been used for this Message</param>
/// <param name="OpSocket">The OperationalSocket that has been used for this Message</param>
internal int SendMessage(IMessage Message, Header Header, Feature feature = null, OperationalSocket OpSocket = null)
{
lock (SendLock)
{
if (!Connected)
{
return(-1);
}
if (Message == null)
{
throw new ArgumentException("Message cannot be null");
}
if (Header == null)
{
throw new ArgumentException("Header cannot be null");
}
ushort HeaderId = OpSocket != null?OpSocket.Headers.GetHeaderId(Header) : Headers.GetHeaderId(Header);
byte[] SerializedHeader = Header.Serialize(Header);
uint messageId = OpSocket != null?OpSocket.MessageHandler.GetMessageId(Message.GetType()) : messageHandler.GetMessageId(Message.GetType());
if (SerializedHeader.Length >= MAX_PACKET_SIZE)
{
throw new ArgumentException("Header length cannot be greater then " + MAX_PAYLOAD);
}
using (MemoryStream outStream = new MemoryStream())
using (PayloadWriter pw = new PayloadWriter(outStream))
{
pw.WriteBytes(new byte[HEADER_SIZE], 0, HEADER_SIZE); //reserve space
pw.WriteBytes(SerializedHeader);
pw.WriteUInteger(messageId);
int packetSize = messageHandler.EncryptMessage(this, Message, outStream);
if (pw.Length > MAX_PACKET_SIZE)
{
throw new OverflowException("Message size cannot be greater then " + MAX_PACKET_SIZE);
}
int PayloadLength = pw.Length - Connection.HEADER_SIZE;
byte CurPacketId = 0;
int FeatureId = feature != null?feature.GetFeatureId() : -1;
ushort ConnectionId = OpSocket != null ? OpSocket.ConnectionId : (ushort)0;
byte checksum = 0;
checksum += (byte)PayloadLength;
checksum += CurPacketId;
checksum += (byte)ConnectionId;
checksum += (byte)HeaderId;
checksum += (byte)FeatureId;
pw.Position = 0;
pw.WriteThreeByteInteger(PayloadLength); //length
pw.WriteByte(CurPacketId); //cur packet id
pw.WriteUShort(ConnectionId); //Connection Id
pw.WriteUShort(HeaderId); //Header Id
pw.WriteByte(checksum);
pw.WriteInteger(FeatureId);
//encrypt the header
lock (HeaderEncryption)
{
HeaderEncryption.Encrypt(pw.GetBuffer(), 0, HEADER_SIZE);
byte[] temp = pw.GetBuffer();
headerConfuser.Obfuscate(ref temp, 0);
}
int SendNum = 0;
try
{
for (int i = 0; i < outStream.Length;)
{
int len = i + 65535 < outStream.Length ? 65535 : (int)outStream.Length - i;
Handle.Send(outStream.GetBuffer(), i, len, SocketFlags.None);
i += len;
SendNum += len;
}
}
catch (Exception ex)
{
Disconnect();
return(-1);
}
SysLogger.Log("Send " + outStream.Length, SysLogType.Network);
PacketsOut++;
DataOut += (ulong)outStream.Length;
this.LastPacketSendSW = Stopwatch.StartNew();
return(SendNum);
}
/*using (OptimizedPayloadStream ms = new OptimizedPayloadStream(SerializedHeader, HeaderId, feature, OpSocket))
* {
* ms.Write(BitConverter.GetBytes(messageId), 0, 4);
*
* MemoryStream stream = ms.PayloadFrames[ms.PayloadFrames.Count - 1];
*
* int ReservedPos = (int)stream.Position;
* ms.Write(new byte[3], 0, 3); //reserve space
*
* ms.WritingMessage = true;
* Serializer.Serialize(ms, Message);
* ms.WritingMessage = false;
*
* using (PayloadWriter pw = new PayloadWriter(new MemoryStream(stream.GetBuffer())))
* {
* pw.Position = ReservedPos; //skip MessageId data
* pw.WriteThreeByteInteger(ms.MessageLength);//Reserved Space + MessageId = 7
* }
* ms.Commit(this);
*
* for (int i = 0; i < ms.PayloadFrames.Count; i++)
* {
* stream = ms.PayloadFrames[i];
*
* lock (HeaderEncryption)
* {
* HeaderEncryption.Encrypt(stream.GetBuffer(), 0, HEADER_SIZE);
*
* byte[] temp = stream.GetBuffer();
* headerConfuser.Obfuscate(ref temp, 0);
* }
* //lock (PayloadEncryption)
* //{
* // PayloadEncryption.Encrypt(stream.GetBuffer(), HEADER_SIZE, (int)stream.Length - HEADER_SIZE);
* //}
*
* Handle.Send(stream.GetBuffer(), 0, (int)stream.Length, SocketFlags.None);
* }
* }*/
}
}