внедрение пакетов

    public class ProcessMemoryReader : IDisposable
    {
        private readonly IntPtr hProcess;
        private readonly Process process;
 
        public ProcessMemoryReader(string processName)
        {
            Process[] processesByName = Process.GetProcessesByName(processName);
 
            if (processesByName.Length == 0)
            {
                throw new Exception(processName + " isn't running!");
            }
 
            process = processesByName[0];
            hProcess = Imported.OpenProcess(Imported.ProcessAccessFlags.VM_READ, false, process.Id);
 
            if (this.hProcess == IntPtr.Zero)
            {
                throw new Win32Exception(Marshal.GetLastWin32Error());
            }
        }
 
        public void Dispose()
        {
            process.Close();
            process.Dispose();
            Imported.CloseHandle(hProcess);
            GC.SuppressFinalize(this);
        }
 
        ~ProcessMemoryReader()
        {
            process.Close();
            process.Dispose();
        }
 
        public byte[] Read(uint offset, int length)
        {
            byte[] lpBuffer = new byte[length];
 
            Imported.ReadProcessMemory(hProcess, new IntPtr(offset), lpBuffer, new UIntPtr((uint)length), IntPtr.Zero);
 
            return lpBuffer;
        }
 
        public uint ReadUInt(uint offset)
        {
            byte[] lpBuffer = new byte[4];
 
            Imported.ReadProcessMemory(hProcess, new IntPtr(offset), lpBuffer, new UIntPtr(4), IntPtr.Zero);
 
            return BitConverter.ToUInt32(lpBuffer, 0);
        }
    }

        /// <summary>
        /// The Microsoft Windows security model enables you to control access to process objects.
        /// </summary>
        public enum ProcessAccessFlags
        {
            /// <summary>
            /// [0x0080] 
            /// Required to create a process.
            /// </summary>
            CREATE_PROCESS              = 0x0080,
            /// <summary>
            /// [0x0002] 
            /// Required to create a thread.
            /// </summary>
            CREATE_THREAD               = 0x0002,
            /// <summary>
            /// [0x0040] 
            /// Required to duplicate a handle using DuplicateHandle.
            /// </summary>
            DUP_HANDLE                  = 0x0040,
            /// <summary>
            /// [0x0400] 
            /// Required to retrieve certain information about a process, 
            /// such as its token, exit code, and priority class 
            /// (see OpenProcessToken, GetExitCodeProcess, GetPriorityClass, and IsProcessInJob).
            /// </summary>
            QUERY_INFORMATION           = 0x0400,
            /// <summary>
            /// [0x1000] 
            /// Required to retrieve certain information about a process 
            /// (see QueryFullProcessImageName). 
            /// A handle that has the PROCESS_QUERY_INFORMATION access right 
            /// is automatically granted PROCESS_QUERY_LIMITED_INFORMATION.
            /// </summary>
            QUERY_LIMITED_INFORMATION   = 0x1000,
            /// <summary>
            /// [0x0200] 
            /// Required to set certain information about a process, such as its priority class (see SetPriorityClass).
            /// </summary>
            SET_INFORMATION             = 0x0200,
            /// <summary>
            /// [0x0100]
            /// Required to set memory limits using SetProcessWorkingSetSize.
            /// </summary>
            SET_QUOTA                   = 0x0100,
            /// <summary>
            /// [0x0800]
            /// Required to suspend or resume a process.
            /// </summary>
            SUSPEND_RESUME              = 0x0800,
            /// <summary>
            /// [0x0001]
            /// Required to terminate a process using TerminateProcess.
            /// </summary>
            TERMINATE                   = 0x0001,
            /// <summary>
            /// [0x0008]
            /// Required to perform an operation on the address space of a process (see VirtualProtectEx and WriteProcessMemory).
            /// </summary>
            VM_OPERATION                = 0x0008,
            /// <summary>
            /// [0x0010] 
            /// Required to read memory in a process using ReadProcessMemory.
            /// </summary>
            VM_READ                     = 0x0010,
            /// <summary>
            /// [0x0020]
            /// Required to write to memory in a process using WriteProcessMemory.
            /// </summary>
            VM_WRITE                    = 0x0020,
            /// <summary>
            /// [0x00100000]
            /// Required to wait for the process to terminate using the wait functions.
            /// </summary>
            SYNCHRONIZE                 = 0x00100000,
            /// <summary>
            /// [0x001F0FFF]
            /// All possible access rights for a process object.
            /// </summary>
            ALL_ACCESS                  = 0x001F0FFF,
        }

        private static void GrantDebuggerPrivileges(Process process)
        {
            IntPtr MyToken = IntPtr.Zero;
            Imported.OpenProcessToken(process.Handle, 0x28, ref MyToken);
            Imported.PrivilegeToken new_priv;
 
            new_priv.Count = 1;
            new_priv.Luid = 0;
            new_priv.Attr = 0x2;
 
            Imported.LookupPrivilegeValue(null, "SeDebugPrivilege", ref new_priv.Luid);
            Imported.AdjustTokenPrivileges(MyToken, false, ref new_priv, 0x10, IntPtr.Zero, IntPtr.Zero);
 
            Console.WriteLine("Granted debugger priviligies to process {0}.", process.Id);
        }