C#/C++ dll injection / hooking

kuhkuh · 4. März 2013

Hey StageTwo Coder,

Ich bin dabei eine 32-bit DLL in einen 32-bit Prozess auf einem 64-bit System zu injecten.
Die DLL enthält einen hook.

So nun zu meinem Problem. Ich kann die DLL zwar erfolgreich injecten (MessageBox erscheint), jedoch wird der hook nicht durchgeführt.
Ich finde das sehr mysteriös, denn wenn ich einen in C++ geschriebenen Injector nehme, dann funktioniert das ganze und der hook greift.
Habe schon etliche C# Injectoren aus dem Internet getestet und keiner geht. Mein eigener auch nicht.

Habt ihr einen Rat?

Kuh

Code:

Code

public bool Inject()
{
UIntPtr bytesout;
IntPtr bytesout2;
Int32 LenWrite = dllFilePath.Length;
ASCIIEncoding enc = new ASCIIEncoding();
adjustDebugPriv(procID);
IntPtr hProcess = OpenProcess(ProcessAccess.AllAccess, false, procID);
if (hProcess == null)
return false;
IntPtr AllocMem = (IntPtr)VirtualAllocEx(hProcess, (IntPtr)null, (uint)LenWrite, 0x1000, 0x40);
if (AllocMem == null)
return false;
bool wpm = WriteProcessMemory(hProcess, AllocMem, enc.GetBytes(dllFilePath), (uint)LenWrite, out bytesout);
if (!wpm)
return false;
UIntPtr Injector = (UIntPtr)GetProcAddress(API.GetModuleHandle("kernel32.dll"), "LoadLibraryA");
if (Injector == null)
return false;
IntPtr hThread = (IntPtr)CreateRemoteThread(hProcess, (IntPtr)null, 0, Injector, AllocMem, 0, out bytesout2);
if (hThread == null)
return false;
uint Result = API.WaitForSingleObject(hThread,10 * 10000);
if (Result == 0x00000080L || Result == 0x00000102L || Result == 0xFFFFFFFF)
{
if (hThread != null)
API.CloseHandle(hThread);
return false;
}
Thread.Sleep(1000);
API.VirtualFreeEx(hProcess, AllocMem, 0, FreeType.Release);
if (hThread != null)
API.CloseHandle(hThread);
return true;
}

Alles anzeigen

dongdong · 4. März 2013

Warum machst du dir dann keine c++ DLL, wenn es mit c++ funktioniert?
Einfach ne c++ DLL machen und in dein c# Programm importieren.

kuhkuh · 4. März 2013

Es ist eine C++ DLL. Ich versuche sie von einem C# Programm aus in einen Prozess zu injecten. Das klappt auch, wie oben beschrieben, aber der hook wird einfach nicht ausgeführt.
Und ich versteh einfach nicht wieso. C++ Injectoren klappen ohne weiteres.

Kuh

Wenn mal wer drüberschauen möchte: 535 889 443 | 7968

**Dickernoob** · 4. März 2013

Hier mal meine Klasse vom alten Silkroad Zeug , die hat immer 100% funktioniert(DoInject(Process,DLLPath)). Da ist evtl noch unützes Zeug dabei, hatte jetzt keine Lust was rauszustreichen

Spoiler anzeigen

Code

class WinAPI
{
[DllImport("kernel32.dll")]
public static extern IntPtr CreateMutex(IntPtr lpMutexAttributes, bool bInitialOwner, string lpName);
/// <summary>
/// Reads raw bytes from another process' memory.
/// </summary>
/// <param name="hProcess">Handle to the external process.</param>
/// <param name="dwAddress">Address from which to read.</param>
/// <param name="lpBuffer">[Out] Allocated buffer into which raw bytes will be read. (Hint: Use Marshal.AllocHGlobal)</param>
/// <param name="nSize">Number of bytes to be read.</param>
/// <param name="lpBytesRead">[Out] Number of bytes actually read.</param>
/// <returns>Returns true on success, false on failure.</returns>
[DllImport("kernel32", EntryPoint = "ReadProcessMemory")]
public static extern bool ReadProcessMemory(IntPtr hProcess, uint dwAddress, ref byte[] lpBuffer, int nSize, out int lpBytesRead);
[DllImport("kernel32", EntryPoint = "WriteProcessMemory")]
public static extern bool WriteProcessMemory(IntPtr hProcess, uint dwAddress, IntPtr lpBuffer, int nSize, out IntPtr iBytesWritten);
[DllImport("kernel32.dll")]
public static extern IntPtr OpenProcess(UInt32 dwDesiredAccess, Int32 bInheiritHandle, IntPtr dwProcessId);
public static uint Rights = 0x0010 | 0x0020 | 0x0008;
public static bool WriteBytes(IntPtr hProcess, uint dwAdress, byte[] lpByteBuffer, int nSize)
{
IntPtr iBytesWritten = IntPtr.Zero;
IntPtr lpBuffer = GCHandle.Alloc(lpByteBuffer, GCHandleType.Pinned).AddrOfPinnedObject();
return WriteProcessMemory(hProcess, dwAdress, lpBuffer, nSize, out iBytesWritten);
}
public static bool DoInject(
Process pToBeInjected,
string sDllPath)
{
IntPtr hwnd = IntPtr.Zero;
string sError = null;
if (!CRT(pToBeInjected, sDllPath, out sError, out hwnd)) //CreateRemoteThread
{
//close the handle, since the method wasn't able to get to that
if (hwnd != (IntPtr)0)
CloseHandle(hwnd);
return false;
}
int wee = Marshal.GetLastWin32Error();
Console.WriteLine(wee);
return true;
}
private static bool CRT(
Process pToBeInjected,
string sDllPath,
out string sError,
out IntPtr hwnd)
{
sError = String.Empty; //in case we encounter no errors
IntPtr hndProc = OpenProcess(
(0x2 | 0x8 | 0x10 | 0x20 | 0x400), //create thread, query info, operation
//write, and read
1,
(uint)pToBeInjected.Id);
hwnd = hndProc;
if (hndProc == (IntPtr)0)
{
sError = "Unable to attatch to process.\n";
sError += "Error code: " + Marshal.GetLastWin32Error();
return false;
}
IntPtr lpLLAddress = GetProcAddress(
GetModuleHandle("kernel32.dll"),
"LoadLibraryA");
if (lpLLAddress == (IntPtr)0)
{
sError = "Unable to find address of \"LoadLibraryA\".\n";
sError += "Error code: " + Marshal.GetLastWin32Error();
return false;
}
IntPtr lpAddress = VirtualAllocEx(
hndProc,
(IntPtr)null,
(IntPtr)sDllPath.Length, //520 bytes should be enough
(uint)VAE_Enums.AllocationType.MEM_COMMIT |
(uint)VAE_Enums.AllocationType.MEM_RESERVE,
(uint)VAE_Enums.ProtectionConstants.PAGE_EXECUTE_READWRITE);
if (lpAddress == (IntPtr)0)
{
if (lpAddress == (IntPtr)0)
{
sError = "Unable to allocate memory to target process.\n";
sError += "Error code: " + Marshal.GetLastWin32Error();
return false;
}
}
byte[] bytes = CalcBytes(sDllPath);
IntPtr ipTmp = IntPtr.Zero;
WriteProcessMemory(
hndProc,
lpAddress,
bytes,
(uint)bytes.Length,
out ipTmp);
if (Marshal.GetLastWin32Error() != 0)
{
sError = "Unable to write memory to process.";
sError += "Error code: " + Marshal.GetLastWin32Error();
return false;
}
IntPtr ipThread = CreateRemoteThread(
hndProc,
(IntPtr)null,
(IntPtr)0,
lpLLAddress,
lpAddress,
0,
(IntPtr)null);
if (ipThread == (IntPtr)0)
{
sError = "Unable to load dll into memory.";
sError += "Error code: " + Marshal.GetLastWin32Error();
return false;
}
return true;
}
private static byte[] CalcBytes(string sToConvert)
{
byte[] bRet = System.Text.Encoding.ASCII.GetBytes(sToConvert);
return bRet;
}
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr OpenProcess(
UInt32 dwDesiredAccess,
Int32 bInheritHandle,
UInt32 dwProcessId);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern Int32 CloseHandle(
IntPtr hObject);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr GetProcAddress(
IntPtr hModule,
string lpProcName);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr GetModuleHandle(
string lpModuleName);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr VirtualAllocEx(
IntPtr hProcess,
IntPtr lpAddress,
IntPtr dwSize,
uint flAllocationType,
uint flProtect);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern Int32 WriteProcessMemory(
IntPtr hProcess,
IntPtr lpBaseAddress,
byte[] buffer,
uint size,
out IntPtr lpNumberOfBytesWritten);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr CreateRemoteThread(
IntPtr hProcess,
IntPtr lpThreadAttribute,
IntPtr dwStackSize,
IntPtr lpStartAddress,
IntPtr lpParameter,
uint dwCreationFlags,
IntPtr lpThreadId);
public static class VAE_Enums
{
public enum AllocationType
{
MEM_COMMIT = 0x1000,
MEM_RESERVE = 0x2000,
MEM_RESET = 0x80000,
}
public enum ProtectionConstants
{
PAGE_EXECUTE = 0X10,
PAGE_EXECUTE_READ = 0X20,
PAGE_EXECUTE_READWRITE = 0X40,
PAGE_EXECUTE_WRITECOPY = 0X80,
PAGE_NOACCESS = 0X01
}
}
}

Alles anzeigen

kuhkuh · 4. März 2013

Vielen Dank! Ich werds testen.

E: Geht leider auch nicht. Heißt nicht, dass es generell nicht geht. Eher im Gegenteil. Liegt zu 100% an mir.
Ich vermute zur Zeit, dass es an der DLL liegt. Vielleicht liegt es an VS11. Ich werde mir mal die 2008er Version von C++ laden und mich dann wieder melden und berichten.

E2: Nope. Geht nicht.

E3: Hab den Übeltäter gefunden. VS11 (C#) ist anscheinend bugged. Mit VS10 (C#) geht es ohne Probleme, bei gleichem Code. Kann geschlossen werden. Vielen Dank für die Bemühungen

dongdong · 4. März 2013

Ich meinte auch nicht die DLL die du in den Prozess injecten willst, sondern eine DLL die eine Funktion beinhaltet zum injecten einer DLL. Dann musst du nicht die ganzen WinApi Funktionen importieren (dabei kann man auch einiges falsch machen). So hast du dann eine native C++ DLL die das injecten für dich übernimmt. Ist meiner Erfahrung nach auch um einiges zuverlässiger als das injecten per c# (Kann auch sein, dass mein Code damals zum injecten in c# nicht ganz fehlerfrei war).

kuhkuh · 5. März 2013

Ah ja, hab das wohl falsch verstanden

Hab diesen Thread mal wieder öffnen lassen, weil es doch am Code lag und nicht an VS11.
ThreadState des Prozesses war auf Sleep gesetzt :'o

Teilen