private static void ExtractEmbeddedResource(string resourceName, string outputPath)
{ Assembly executingAssembly = Assembly.GetExecutingAssembly();
// Get the embedded resource stream
using (Stream resourceStream =
executingAssembly.GetManifestResourceStream(resourceName))
{
if (resourceStream == null)
{
throw new ArgumentException($"Resource '{resourceName}' not found.");
}
// Read the embedded resource and save it to the specified path
using (FileStream fileStream = new FileStream(outputPath, FileMode.Create))
{
byte[] buffer = new byte[resourceStream.Length];
resourceStream.Read(buffer, 0, buffer.Length);
fileStream.Write(buffer, 0, buffer.Length);
}
}
}
// Global variables to store the target process handle and the remote module
handle.
private IntPtr remoteModuleHandle = IntPtr.Zero;
private IntPtr hTargetProcess = IntPtr.Zero;
private string tempDllPath = Path.Combine(Path.GetTempPath(), "ALPHA.dll");
// P/Invoke declarations
[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle,
int dwProcessId);
[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress,
IntPtr dwSize, uint flAllocationType, uint flProtect);
[DllImport("kernel32.dll", SetLastError = true)]
static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr
lpBaseAddress, byte[] lpBuffer, uint nSize, out IntPtr lpNumberOfBytesWritten);
[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr
lpThreadAttributes, IntPtr dwStackSize,
IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr
lpThreadId);
[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);
[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr GetModuleHandle(string lpModuleName);
[DllImport("kernel32.dll", SetLastError = true)]
static extern uint WaitForSingleObject(IntPtr hHandle, uint
dwMilliseconds);
[DllImport("kernel32.dll", SetLastError = true)]
static extern bool GetExitCodeThread(IntPtr hThread, out IntPtr
lpExitCode);
[DllImport("kernel32.dll", SetLastError = true)]
static extern bool VirtualFreeEx(IntPtr hProcess, IntPtr lpAddress, IntPtr
dwSize, uint dwFreeType);
// Constants
const uint PROCESS_CREATE_THREAD = 0x0002;
const uint PROCESS_QUERY_INFORMATION = 0x0400;
const uint PROCESS_VM_OPERATION = 0x0008;
const uint PROCESS_VM_WRITE = 0x0020;
const uint PROCESS_VM_READ = 0x0010;
const uint MEM_COMMIT = 0x00001000;
const uint MEM_RELEASE = 0x8000;
const uint PAGE_READWRITE = 0x04;
const uint INFINITE = 0xFFFFFFFF;
// Dummy method to extract an embedded resource to a file.
// (Implement this as needed.)
Button:-
// Define target process and resource names.
string processName = "HD-Player";
string dllResourceName = "External.PC CORP Chams Menu.dll"; //
Ensure this exactly matches your embedded resource name
// Extract the embedded DLL to the temporary file (ALPHA.dll)
ExtractEmbeddedResource(dllResourceName, tempDllPath);
// Find the target process.
Process[] targetProcesses =
Process.GetProcessesByName(processName);
if (targetProcesses.Length == 0)
{
status.text = "Emulator Not Found"
status.Forecolor = color.Red;
}
Process targetProcess = targetProcesses[0];
// Open the target process with required rights.
hTargetProcess = OpenProcess(PROCESS_CREATE_THREAD |
PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE |
PROCESS_VM_READ,
false, targetProcess.Id);
// Allocate memory in the target process for the DLL path.
IntPtr allocMemAddress = VirtualAllocEx(hTargetProcess,
IntPtr.Zero, (IntPtr)tempDllPath.Length, MEM_COMMIT, PAGE_READWRITE);
// Write the DLL path into the allocated memory.
IntPtr bytesWritten;
WriteProcessMemory(hTargetProcess, allocMemAddress,
Encoding.ASCII.GetBytes(tempDllPath),
(uint)tempDllPath.Length, out bytesWritten);
// Get the address of LoadLibraryA in kernel32.dll.
IntPtr loadLibraryAddr =
GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
// Create a remote thread to call LoadLibraryA with the DLL path.
IntPtr hThread = CreateRemoteThread(hTargetProcess, IntPtr.Zero,
IntPtr.Zero, loadLibraryAddr, allocMemAddress, 0, IntPtr.Zero);
// Wait for the remote thread to finish.
WaitForSingleObject(hThread, INFINITE);
// Retrieve the module handle (the return value of LoadLibraryA)
from the remote thread.
GetExitCodeThread(hThread, out remoteModuleHandle);
// Free the allocated memory in the target process.
VirtualFreeEx(hTargetProcess, allocMemAddress, IntPtr.Zero,
MEM_RELEASE);
