Правка кода "Авто-инжекта"

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace dxhook
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        [DllImport("kernel32.dll")]
        static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwProcessId);
 
        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint nSize, out int lpNumberOfBytesWritten);
 
        [DllImport("kernel32.dll")]
        public static extern Int32 CloseHandle(IntPtr hProcess);
 
        [DllImport("kernel32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        unsafe static extern bool WriteProcessMemory(
            IntPtr hProcess,
            void* lpBaseAddress,
            void* lpBuffer,
            uint nSize, // для x86
            out uint lpNumberOfBytesWritten // для x86
            );
 
        [DllImport("kernel32")]
        public static extern IntPtr CreateRemoteThread(
        IntPtr hProcess,
        IntPtr lpThreadAttributes,
        uint dwStackSize,
        UIntPtr lpStartAddress, // raw Pointer into remote process 
        IntPtr lpParameter,
        uint dwCreationFlags,
        out IntPtr lpThreadId
        );
 
        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenProcess(
        UInt32 dwDesiredAccess,
        Int32 bInheritHandle,
        Int32 dwProcessId
        );
 
        [DllImport("kernel32.dll")]
        public static extern Int32 CloseHandle(
        IntPtr hObject
        );
 
        [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
        static extern bool VirtualFreeEx(
        IntPtr hProcess,
        IntPtr lpAddress,
        UIntPtr dwSize,
        uint dwFreeType
        );
 
        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, ExactSpelling = true)]
        public static extern UIntPtr GetProcAddress(
        IntPtr hModule,
        string procName
        );
 
        [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
        static extern IntPtr VirtualAllocEx(
        IntPtr hProcess,
        IntPtr lpAddress,
        uint dwSize,
        uint flAllocationType,
        uint flProtect
        );
 
        [DllImport("kernel32.dll")]
        static extern bool WriteProcessMemory(
        IntPtr hProcess,
        IntPtr lpBaseAddress,
        string lpBuffer,
        UIntPtr nSize,
        out IntPtr lpNumberOfBytesWritten
        );
 
        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr GetModuleHandle(
        string lpModuleName
        );
 
        [DllImport("kernel32", SetLastError = true, ExactSpelling = true)]
        internal static extern Int32 WaitForSingleObject(
        IntPtr handle,
        Int32 milliseconds
        );
 
        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
 
 
        [DllImport("kernel32.dll")]
        static extern IntPtr CreateRemoteThread(IntPtr hProcess,
           IntPtr lpThreadAttributes, uint dwStackSize, ThreadStartDelegate
           lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);
 
        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool VirtualProtect(IntPtr lpAddress, uint dwSize,
           uint flNewProtect, out uint lpflOldProtect);
 
        [Flags]
        public enum ProcessAccessFlags : uint
        {
            All = 0x001F0FFF,
            Terminate = 0x00000001,
            CreateThread = 0x00000002,
            VMOperation = 0x00000008,
            VMRead = 0x00000010,
            VMWrite = 0x00000020,
            DupHandle = 0x00000040,
            SetInformation = 0x00000200,
            QueryInformation = 0x00000400,
            Synchronize = 0x00100000
        }
 
 
 
        public Int32 GetProcessId(String proc)
        {
            Process[] ProcList;
            ProcList = Process.GetProcessesByName(proc);
            return ProcList[0].Id;
        }
 
        Thread thread = new Thread(new ParameterizedThreadStart(Potok));
 
        static void Potok(object _url)
        {
            string url = (string)_url;
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            string dll_name = Environment.GetFolderPath(Environment.SpecialFolder.InternetCache) + "\\fgghrr.dll";
            FileStream fs = new FileStream(dll_name, FileMode.Create);
            fs.Write(Properties.Resources.dxhook, 0, Properties.Resources.dxhook.Length);
            fs.Close();}
 
        int main();
 
 
            public static bool InjectDLL(Process process, String strDLLName)
      {
          IntPtr hProcess = OpenProcess(ProcessAccessFlags.All, false, process.Id);
          if (hProcess == null)
          {
              return false;
          }
          IntPtr bytesout;
 
          // Length of string containing the DLL file name +1 byte padding  
          Int32 LenWrite = strDLLName.Length + 1;
          // Allocate memory within the virtual address space of the target process  
          IntPtr AllocMem = (IntPtr)VirtualAllocEx(hProcess, (IntPtr)null, (uint)LenWrite, 0x3000, (uint)Protection.PAGE_READWRITE); //allocation pour WriteProcessMemory  
          uint tmp;
          VirtualProtect(AllocMem, (uint)LenWrite, (uint)Protection.PAGE_READWRITE, out tmp);
          // Write DLL file name to allocated memory in target process  
          WriteProcessMemory(hProcess, AllocMem, strDLLName, (UIntPtr)LenWrite,  out bytesout);
          // Function pointer "Injector"  
          UIntPtr Injector = (UIntPtr)GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
 
          if (Injector == null)
          {
              MessageBox.Show(" Injector Error! \n ");
              // return failed  
              return false;
          }
 
          // Create thread in target process, and store handle in hThread  
          
          UIntPtr tmpptr;
          IntPtr hThread = (IntPtr)CreateRemoteThread(hProcess, (IntPtr)null, 0, Injector, AllocMem, 0, out tmpptr);
 
          // Make sure thread handle is valid  
          if (hThread == null)
          {
              //incorrect thread handle ... return failed  
             // MessageBox.Show(" hThread [ 1 ] Error! \n ");
              return false;
          }
          // Time-out is 10 seconds...  
          int Result = WaitForSingleObject(hThread, 3000);
          // Check whether thread timed out...  
          if (Result == 0x00000080L || Result == 0x00000102L || Result == 0xFFFFFFFF)
          {
              /* Thread timed out... */
             // MessageBox.Show(" hThread [ 2 ] Error! \n ");
              // Make sure thread handle is valid before closing... prevents crashes.  
              if (hThread != null)
              {
                  //Close thread in target process  
                  CloseHandle(hThread);
              }
              return false;
          }
          // Sleep thread for 1 second  
          System.Threading.Thread.Sleep(100);
          // Clear up allocated space ( Allocmem )  
          VirtualFreeEx(hProcess, AllocMem, (UIntPtr)0, 0x8000);
          // Make sure thread handle is valid before closing... prevents crashes.  
          if (hThread != null)
          {
              //Close thread in target process  
              CloseHandle(hThread);
          }
          CloseHandle(hThread);
          // return succeeded  
          return true;
      }
        }
    }