C++ Injection Fail

[freehuntx]

Hi leute,

ich wollte einen Injector für einen hack machen, aber er funktioniert aus irgendeinem Grund nicht.

Könnte sich vielleicht jemand den source angucken und sagen was ich falsch mache?

#include <Windows.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <string>
#include <tlhelp32.h>


#define MAXWAIT 10000
     
using namespace std;

DWORD FindProcessId(const std::wstring& processName)
    {
        PROCESSENTRY32 processInfo;
        processInfo.dwSize = sizeof(processInfo);
     
        HANDLE processesSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
        if ( processesSnapshot == INVALID_HANDLE_VALUE )
            return 0;
     
        Process32First(processesSnapshot, &processInfo);
        if ( !processName.compare(processInfo.szExeFile) )
        {
            CloseHandle(processesSnapshot);
            return processInfo.th32ProcessID;
        }
     
        while ( Process32Next(processesSnapshot, &processInfo) )
        {
            if ( !processName.compare(processInfo.szExeFile) )
            {
                CloseHandle(processesSnapshot);
                return processInfo.th32ProcessID;
            }
        }
     
        CloseHandle(processesSnapshot);
        return 0;
    }


bool insertDll(DWORD procID, std::string dll)
    {
        //Find the address of the LoadLibrary api, luckily for us, it is loaded in the same address for every process
        HMODULE hLocKernel32 = GetModuleHandleA("Kernel32");
        FARPROC hLocLoadLibrary = GetProcAddress(hLocKernel32, "LoadLibraryA");
       
        //Adjust token privileges to open system processes
        HANDLE hToken;
        TOKEN_PRIVILEGES tkp;
        if(OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
        {
            LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tkp.Privileges[0].Luid);
            tkp.PrivilegeCount = 1;
            tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
            AdjustTokenPrivileges(hToken, 0, &tkp, sizeof(tkp), NULL, NULL);
        }
     
        //Open the process with all access
        HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, procID);
     
        //Allocate memory to hold the path to the Dll File in the process's memory
        dll += '\0';
        LPVOID hRemoteMem = VirtualAllocEx(hProc, NULL, dll.size(), MEM_COMMIT, PAGE_READWRITE);
     
        //Write the path to the Dll File in the location just created
        DWORD numBytesWritten;
        WriteProcessMemory(hProc, hRemoteMem, dll.c_str(), dll.size(), &numBytesWritten);
     
        //Create a remote thread that starts begins at the LoadLibrary function and is passed are memory pointer
        HANDLE hRemoteThread = CreateRemoteThread(hProc, NULL, 0, (LPTHREAD_START_ROUTINE)hLocLoadLibrary, hRemoteMem, 0, NULL);
     
        cout << hRemoteThread << endl;
     
        //Wait for the thread to finish
        bool res = false;
        if (hRemoteThread)
            res = (bool)WaitForSingleObject(hRemoteThread, MAXWAIT) != WAIT_TIMEOUT;
     
        //Free the memory created on the other process
        VirtualFreeEx(hProc, hRemoteMem, dll.size(), MEM_RELEASE);
     
        //Release the handle to the other process
        CloseHandle(hProc);
     
        return res;
}

int main(HANDLE hConsole)
{
	SetConsoleTitleA("JustHack Launcher");
	cout <<"==================================== JustHack =================================="<< endl;
	cout <<"================================================================================"<< endl;
	while (1)
	{
	if(!FindProcessId(L"S4Client.exe"))
	{
	}
	else
	{
	Sleep(100);
	DWORD PID = FindProcessId(L"S4Client.exe");
     insertDll(PID,"JustHack.dll");
	 Sleep(100);
     return TRUE;
	 ExitProcess(0);
	}
}
}

[Medix]

Ich schätze mal dir fehlt folgendes:

bool EnableDebugPrivilege()
{
    TOKEN_PRIVILEGES priv;
    HANDLE hThis, hToken;
    LUID luid;
    hThis = GetCurrentProcess();
    OpenProcessToken(hThis, TOKEN_ADJUST_PRIVILEGES, &hToken);
    LookupPrivilegeValue(0, "seDebugPrivilege", &luid);
    priv.PrivilegeCount = 1;
    priv.Privileges[0].Luid = luid;
    priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    AdjustTokenPrivileges(hToken, false, &priv, 0, 0, 0);
    CloseHandle(hToken);
    CloseHandle(hThis);
    return true;
}

[Bot_interesierter]

@Medix
Die Privileges setzt er doch in der insertDll Funktion, die übrigens Copypasta von Codeproject ist und allgemein keinen zuverlässigen Weg für eine Dll Injektion darstellt.

Es ist eine ganze Menge Mist in diesem Code, beispielsweise sollte man PROCESS_ALL_ACCESS niemals verwenden, stattdessen sollte man sich nur die Rechte holen die man wirklich braucht, welche das genau sind ist auf MSDN nachzulesen.
Dann wäre da noch das die insertDll Funktionen einen std::string als zweites Argument nimmt, der TE allerdings einen const char* übergibt, außerdem wird in Tokenhandle geleakt.
@TE
Wir brauchen mehr Informationen um dir ordentlich helfen zu können, welches Windows verwendest du, handelt es sich um eine 32bit oder 64bit Applikation, hast du schon überprüft ob der String ordentlich in den Zielprozess geschrieben wird?
Auch ist es möglich das in deinem Zielprozess ASLR aktiv ist, damit wäre deine Methode die LoadLibraryA Funktion zu lokalisieren schonmal nicht korrekt.
Übrigens ist es besser einen richtigen ThreadProc in den Zielprozess zu injizieren und über diesen dann die LoadLibrary API aufzurufen, denn die LoadLibrary API ist nicht dazu gemacht über CreateRemoteThread aufgerufen zu werden.

[freehuntx]

Originally Posted by Bot_interesierter

@Medix
Die Privileges setzt er doch in der insertDll Funktion, die übrigens Copypasta von Codeproject ist und allgemein keinen zuverlässigen Weg für eine Dll Injektion darstellt.

Es ist eine ganze Menge Mist in diesem Code, beispielsweise sollte man PROCESS_ALL_ACCESS niemals verwenden, stattdessen sollte man sich nur die Rechte holen die man wirklich braucht, welche das genau sind ist auf MSDN nachzulesen.
Dann wäre da noch das die insertDll Funktionen einen std::string als zweites Argument nimmt, der TE allerdings einen const char* übergibt, außerdem wird in Tokenhandle geleakt.
@TE
Wir brauchen mehr Informationen um dir ordentlich helfen zu können, welches Windows verwendest du, handelt es sich um eine 32bit oder 64bit Applikation, hast du schon überprüft ob der String ordentlich in den Zielprozess geschrieben wird?
Auch ist es möglich das in deinem Zielprozess ASLR aktiv ist, damit wäre deine Methode die LoadLibraryA Funktion zu lokalisieren schonmal nicht korrekt.
Übrigens ist es besser einen richtigen ThreadProc in den Zielprozess zu injizieren und über diesen dann die LoadLibrary API aufzurufen, denn die LoadLibrary API ist nicht dazu gemacht über CreateRemoteThread aufgerufen zu werden.

Ja die funktion habe ich aus dem interdet, weil ich in c++ keine komplexen funktionen schreiben kann.

- Win7 64-Bit

Ich möchte einen Launcher machen, welcher auf 32, und 64 bit funktionieren sollte.

Er soll eigendlich nur auf den Prozess S4Client.exe warten, und die dll JustHack.dll Injizieren.

Diese Methode hat bei meinem Launcher, welcher den prozes startet funktioniert, aber ich will diesmal nur auf den prozes warten und dann injizieren.

Werde mal schauen was ich machen kann,

[wutax]

Originally Posted by phrenesis

wieso nimmst du nicht einen fertigen injector?

Man muss doch nicht immer einen fertigen nehmen.
Vielleicht will er ja nicht nur hacken, sonder nebenbei auch mal was lernen.

[freehuntx]

Originally Posted by wutax

Man muss doch nicht immer einen fertigen nehmen.
Vielleicht will er ja nicht nur hacken, sonder nebenbei auch mal was lernen.

Mir geht es ja nicht ums injecten an sich, dass könnte ich ja mit perx machen oder in autoit, aber wills einfach in c++ hinbekommen.

Naja werde mir vielleicht nochmal genau angucken müssen wie die insertdll funktion genau funktioniert.

[Medix]

Originally Posted by Bot_interesierter

@Medix
Die Privileges setzt er doch in der insertDll Funktion, die übrigens Copypasta von Codeproject ist und allgemein keinen zuverlässigen Weg für eine Dll Injektion darstellt.

.

ups übersehen

[link]

Debug den Code bzw. bau halt einfach mal ein paar Ausgaben ein:
Lass dir die Handles und Rückgabewerte der einzelnen Funktionen anzeigen, sodass du siehst, wo es nicht mehr weitergeht und dann überprüfst du einfach mit GetLastError, was falsch läuft (GetExitCodeThread zeigt dir den Rückgabewert des Threads an).
Du könntest den Zielprozess auch mal debuggen, um zu sehen, was dein Injector dort eigentlich in den Speicher schreibt.

Btw. bedenke, dass du x64 Dateien nur in x64 Prozesse bzw. x86 Dateien nur in x86 Prozesse injizieren kannst.
Außerdem muss bei deinem VirtualFreeEx-Aufruf der dritte Parameter gleich 0 sein.