4. Problem mit dll injection [ERLEDIGT]

Problem mit dll injection [ERLEDIGT]

  • G

    Sorry für Doppelpost aber ich hab das alles nochmal bisschen umgestaltet. Hab nun auch ne uninject funktion was aber an meinem Problem nichts ändert, da es wie gesagt schon davor auftritt.

    #include <windows.h>
#include <cstdio>
#include <tlhelp32.h>
#include <iostream>
#include <conio.h>
#include <string.h>

using namespace std;

typedef HINSTANCE (*fpLoadLibrary)(char*);
typedef LPVOID (*fpGetProcAddress)(HINSTANCE, char*);
typedef void (*fpFunktion)(void);

BOOL Inject();
BOOL Uninject(DWORD id,HMODULE ah_ModuleHandle);

DWORD  hLibModule = 0;
DWORD id;

struct INJECTSTRUCT
{
      fpLoadLibrary LoadLibrary;
      fpGetProcAddress GetProcAddress;
      char path[255];
      char func[255];
};

DWORD WINAPI threadstart(LPVOID addr)
{
	HINSTANCE hDll;
	fpFunktion funktion;
	INJECTSTRUCT * is = (INJECTSTRUCT*)addr;       
	hDll = is->LoadLibrary(is->path);
	funktion = (fpFunktion)is->GetProcAddress(hDll, is->func);
	funktion();
	return 0;
}
void threadend()
{
}

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;

}

void listproc()
{
	HANDLE hSnap, hTemp;
	PROCESSENTRY32 pe;
	pe.dwSize = sizeof(PROCESSENTRY32);

	EnableDebugPrivilege();

	hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

	if(Process32First(hSnap, &pe))
	{
		do
		{
			hTemp = OpenProcess(PROCESS_ALL_ACCESS, 0, pe.th32ProcessID);
			if(hTemp)
			{
				printf("%4d\t%s\n", pe.th32ProcessID, pe.szExeFile);
				CloseHandle(hTemp);
			}
			if(!hTemp)
			{
				printf("%4d\t%s NO ACCESS\n", pe.th32ProcessID, pe.szExeFile);
				CloseHandle(hTemp);
			}
		}
		while(Process32Next(hSnap, &pe));
	}
}

int main()
{
   listproc();
   if(!(Inject()))
   {
	   MessageBox ( NULL, "Inject failed", "DLL Injector", MB_OK);
	   return 0;
   }
   else
		MessageBox ( NULL, "DLL injected", "DLL Injector", MB_OK);

if(!(Uninject(id,(HMODULE)hLibModule)))
{
	MessageBox ( NULL, "Uninject failed", "DLL Injector", MB_OK);
	   return 0;
   }
else
	MessageBox ( NULL, "DLL uninjected", "DLL Injector", MB_OK);

return 1;
}

BOOL Inject()
{
   HANDLE hProc,hThread ;
   LPVOID start, thread;
   DWORD funcsize;
   HINSTANCE hDll;
   INJECTSTRUCT is;

    hDll = LoadLibrary("KERNEL32");

   is.LoadLibrary = (fpLoadLibrary)GetProcAddress(hDll, "LoadLibraryA");
   is.GetProcAddress = (fpGetProcAddress)GetProcAddress(hDll, "GetProcAddress");
   strcpy_s(is.path, "J:\\Dokumente\\Programmierung\\C++\\DLL\\DLL\\Release\\DLL.dll");
   strcpy_s(is.func, "Funktion");

   funcsize = (DWORD)threadend-(DWORD)threadstart;

   printf("\nProcess ID: ");
   scanf_s("%d", &id);

   hProc = OpenProcess(PROCESS_ALL_ACCESS, false, id);
   if(!hProc)
   {
	   MessageBox ( NULL, "Unable to open process", "DLL Injector", MB_OK);
	   return 0;
   }

   if(!(start = VirtualAllocEx(hProc, 0, funcsize+sizeof(INJECTSTRUCT), MEM_COMMIT, PAGE_READWRITE)))
   {
	   MessageBox ( NULL, "Failed to allocate memory", "DLL Injector", MB_OK);
	   return 0;
   }

   if(!(WriteProcessMemory(hProc, start, (LPVOID)&is, sizeof(INJECTSTRUCT), 0)))
   {
		MessageBox ( NULL, "WriteProcessMemory failed", "DLL Injector", MB_OK);
		return 0;
   }

   thread = (LPVOID)((DWORD)start+sizeof(INJECTSTRUCT));

  if(!(WriteProcessMemory(hProc, thread, (LPVOID)threadstart, funcsize, NULL)))
  {
		MessageBox ( NULL, "WriteProcessMemory(hProc, thread, (LPVOID)threadstart, funcsize, NULL) failed", "DLL Injector", MB_OK);
			return 0;
   }

   if(!(hThread = CreateRemoteThread(hProc, 0, 0, (LPTHREAD_START_ROUTINE)thread, start, 0, 0)))
   {
	   MessageBox ( NULL, "Failed to Create remote thread", "DLL Injector", MB_OK);
	   	return 0;
   }

WaitForSingleObject(hThread, INFINITE);

GetExitCodeThread( hThread, &hLibModule );

  if(!(VirtualFreeEx(hProc,start,0,MEM_RELEASE)))
  {
		MessageBox ( NULL, "Failed to release allocated memory", "DLL Injector", MB_OK);
		return 0;
   }

CloseHandle(hProc);
return 1;
}

BOOL Uninject(DWORD id,HMODULE ah_ModuleHandle)
{
    HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, id);
    if (hProc == NULL)
        return false;

    bool lb_ReturnValue = false;

    HMODULE hLocKernel32 = GetModuleHandleW(L"KERNEL32");
    FARPROC hLocLoadLibrary = GetProcAddress(hLocKernel32, "FreeLibrary");

    if(ah_ModuleHandle != NULL)
    {
        HANDLE hThread = CreateRemoteThread(hProc, NULL, 0, (LPTHREAD_START_ROUTINE)hLocLoadLibrary, (void*)ah_ModuleHandle, 0, NULL );

        if( hThread != NULL )
        {
            DWORD ldw_ReturnCode;
            WaitForSingleObject( hThread, INFINITE );
            GetExitCodeThread( hThread, &ldw_ReturnCode );
            CloseHandle( hThread );

            lb_ReturnValue = ldw_ReturnCode != 0;
        }
    }

    CloseHandle(hProc);

    return lb_ReturnValue; 
}
    0
  • G

    Habs hingekriegt.

    ERLEDIGT

    0
  • ?

    Wie hast du es denn hinbekommen? (Hab das Selbe Problem)

    0
  • ?

    Wie schön, dass ihr mein Posting ignoriert. Naja, wenn euch der Frickelweg lieber ist als 4 und 7 Zeilen...

    🙄

    0
  • ?

    Danke Croker, jetzt gehts. (Ich hatte deinen Post glatt übersehen)

    Ist es normal, das wenn das zu infizierende Programm in einer Schleife läuft, der eingeschläußte code nur einmal ausgeführt wird?

    0
  • ?

    Lt. Code soll er das doch.

    0
  • ?

    Und wie muß ich das abändern, damit das jedesmal duchlaufenwird?

    0
  • ?

    Was meinst du?
    Sobald die DLL in den Prozess gemapped wurde, wird DllMain mit "reason == DLL_PROCESS_ATTACH" aufgerufen.

    0
  • ?

    Hi Crocker,

    ich weiß nicht so genau ob das überhaupt gehr was ich möchte (Ich bin ja schon froh das ich es jetzt hinbekommen habe. Auch den Frickelweg habe ich zum laufen gebracht 😃 )

    Also ich möchte, dass die dll so eingeladen wird, das sie im infizierten Programm immer wieder aufgerufen wird.

    Also wenn das zu infizierende Programm so aussieht.

    int main () 
{
	while (true)
	{
		Sleep(6000);
		cout << "alles ok";
	}
       return 0;
}

    und die DLL so:

    BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
					 )
{
	    return TRUE;
}

void Funktion()
{
	cout << "infiziert";   
}

    Dann passiert bisher folgendes:
    Ausgabe: alles ok alles ok alles ok infiziert alles ok alles ok alles ok...

    Das infiziert kommt genau einmal zu dem zeitpunkt zu dem ich das injection Programm aufrufe.

    Nun hätte ich aber gerne, das Folgendes passiert:
    Ausgabe: alles ok infiziert alles ok infiziert alles ok infiziert...

    Und zwar soll dies möglichst mit nur einem Aufruf des injection Programms möglich sein.
    (Wenn das überhaupt geht)

    0
  • ?

    DllMain wird einmalig mit DLL_PROCESS_ATTACH aufgerufen wenn die DLL injiziert wird, was du darin machst ist doch dir überlassen. Allerdings darf man darin nicht alles tun (google dazu am besten mal (Ich glaube, wenn du in der DllMain eine eigene Funktion aufrufst, darfst du in dieser aber alles tun).
    Probier halt mal rum, mach ne Schleife mit cout rein oder sonstwas.

    bool __stdcall DllMain(HMODULE, unsigned long reason, void*)
{
	if(reason == DLL_PROCESS_ATTACH)
	{
		; // Rufe zB. eine Funktion auf ...
	}
	else if(reason == DLL_PROCESS_DETACH)
	{
		;
	}

    return true;
}
    0
  • ?

    Danke!

    0
Anmelden zum Antworten