Entrypoint einer DLL im Speicher finden

Hallo ich hab ein Programm welches eine DLL läd die eine MessageBox ausgibt.
Jetzt würde ich gerne wissen an welche Adresse im Speicher die DLL gemapped wird ich hab gelesen das soll mit GetModuleHandle gehen.

Mein Programm welches die Adresse auslesen soll liegt im selben Ordner wie die dll Datei.

HMODULE h = GetModuleHandle("test.dll");

Aber GetModuleHandle gibt mir immer 0 zurück. Was mache ich da falsch?

Ich werde auch gleich mal test: GetModuleInformation
http://msdn.microsoft.com/en-us/library/ms683201

Das hört sich zumindest laut MSDN sehr viel versprechend an.

Martin Richter

Dann ist keine DLL mit diesem Namen in Deinem Prozes vorhanden.

Was sagt GetLastError?

GetLastError sagt 126.

ERROR_MOD_NOT_FOUND
126 (0x7E)
The specified module could not be found.

Ich erklär mal kurz was ich genau mache:

Mit diesem Programm lade ich meine DLL:

#include <windows.h>

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow) 
{ 

typedef UINT (CALLBACK* LPFNDLLFUNC1)(DWORD,UINT);

HINSTANCE hDLL;               
LPFNDLLFUNC1 lpfnDllFunc1;    
DWORD dwParam1;
UINT  uParam2, uReturnVal;

hDLL = LoadLibrary("test.dll");
if (hDLL != NULL)
{
   lpfnDllFunc1 = (LPFNDLLFUNC1)GetProcAddress(hDLL,
                                           "TextAusgabe"); 

   if (!lpfnDllFunc1)
   {
   MessageBox(0,"DLL nicht gefunden !","DLL nicht gefunden !",0);
      FreeLibrary(hDLL);
      return 0;
   }

   else
   {
      uReturnVal = lpfnDllFunc1(dwParam1, uParam2);
   }

}

}

Wenn ich das Programm dann starte dann wird aus der DLL meine MessageBox Funktion aufgerufen.

Jetzt starte ich mein Programm was die Adresse der DLL auslesen soll.

#include <windows>
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
HMODULE h = GetModuleHandle("lib.dll");

cout<<h<<" error code: " << GetLastError() << endl;
return 0;
}

Ich hab gerade mal den Windows Taschenrechner gestartet und dort wird ja die Gdi32.dll verwendet.

Daher hab ich das ganze mit GetModuleHandle nochmal mit der Gdi32.dll getestet und da funktionierte es. (Die Adresse hab ich mit Olly überprüft)

Aber wieso lässt sich die Adresse der DLL von meinem Programm nicht ermitteln?

LoadLibrary()

@Solala

In deinem MSDN Link habe ich gelesen:

Module handles are not global or inheritable

Ist das die Lösung warum es mit meinem Programm nicht funktioniert? O_o

Wie soll man den sonst eine DLL laden.

dot

Ich glaub du hast da irgendwo was ganz grundlegend falsch verstanden. Unter Windows hat jeder Prozess seinen eigenen Adressraum. Wenn ein Prozess eine dll lädt, dann wird diese dll in den Adressraum des betreffenden Prozesses gemapped.
Dein Prozess sieht nur die dlls die dein Prozess geladen hat, was andere Prozesse tun geht deinen Prozess nichts an...

Aber das muss man doch auch von fremden Prozessen auslesen können. Der OllyDbg kann das ja auch also muss es ja irgendwie gehen.

Ich hab es auch mal mit GetModuleInformation versucht aber das funktioniert auch nicht.

GetModuleInformation gibt immer den error code 6 aus.(The handle is invalid.)

#include <windows>
#include <iostream>
#include <Tlhelp32>
#include <Psapi.h>
using namespace std;

int main(int argc, char* argv[])
{
bool ret;
HANDLE handle;
HANDLE snap;
PROCESSENTRY32 lppe;
MODULEINFO info;

HMODULE mod;

snap =  CreateToolhelp32Snapshot( TH32CS_SNAPALL, 0 );

        if ( snap == INVALID_HANDLE_VALUE ){
            cout<< "error: " << GetLastError() << endl; system("PAUSE");
            return 0;
        }

        lppe.dwSize = sizeof(PROCESSENTRY32);
        Process32First(  snap, &lppe );

        do
        {
         if( !strcmp(lppe.szExeFile,"Call_DLL.exe") )
           {
                    cout<<lppe.szExeFile << "  Prozess ID: "  << lppe.th32ProcessID << endl;
                    break;
           }
        }
        while ( Process32Next ( snap , &lppe ) == 1 ) ;

        mod = LoadLibrary( "lib.dll");
        if(mod==0){
                cout<<"error: " << GetLastError(); system("PAUSE");
                return 0;
        }

        handle = OpenProcess(PROCESS_ALL_ACCESS, false, lppe.th32ProcessID );
        if (handle==0){
                cout<<"error: " << GetLastError(); system("PAUSE");
                return 0;
        }

        ret = GetModuleInformation (handle , LoadLibrary("lib.dll") ,&info, sizeof(info) );
        if(ret==false)
        {
                cout<<"error: " << GetLastError()<<endl; system("PAUSE");
                return 0;
        }

        else
        {
                cout<<hex<<info.lpBaseOfDll<<endl;
                cout<<info.SizeOfImage<<endl;
                cout<<info.EntryPoint<<endl;
        }

system("PAUSE");
return 0;
}
//---------------------------------------------------------------------------

Martin Richter

Bitte welchen Sinn soll es machen, die Startadresse eine DLL in enem anderen Prozessraum zu finden außer man will irgendwas hacken?

Sag uns einfach was Du wirklich willst!

So ich hab es hinbekommen, bei meinem rum gegoogel habe ich TH32CS_SNAPMODULE entdeckt. (Da hätte ich eigentlich selbst drauf kommen können.)

Naja ich hab das ganze mal zusammen gefrickelt.
So funktioniert es

#include <windows>
#include <iostream>
#include <Tlhelp32>
#include <Psapi.h>
#include <iomanip>
using namespace std;

unsigned RetProcessID();

int main(int argc, char* argv[])
{
HANDLE handle;
HANDLE snap;
MODULEENTRY32 lppe;

unsigned id = RetProcessID();

snap =  CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, id );

        if ( snap == INVALID_HANDLE_VALUE ){
            cout<< "error: " << GetLastError() << endl; system("PAUSE");
            return 0;
        }

        Module32First(  snap, &lppe );

        do
        {

                if ( !strcmp( lppe.szModule,"test.dll") )
                {
                        cout<<lppe.szModule<<endl;
                        cout<<hex<<lppe.hModule<<endl;
                }

        }
        while ( Module32Next ( snap , &lppe ) == 1 ) ;

system("PAUSE");
return 0;
}
//---------------------------------------------------------------------------

unsigned RetProcessID()
{

HANDLE snap;
PROCESSENTRY32 lppe;

snap =  CreateToolhelp32Snapshot( TH32CS_SNAPALL, 0 );

        if ( snap == INVALID_HANDLE_VALUE )
        {

            cout<<"Konnte kein Snapshot machen Fehler code: " << GetLastError() << endl;
            system("PAUSE");
            return 0;
        }

        lppe.dwSize = sizeof(PROCESSENTRY32);
        Process32First(  snap, &lppe );

        do
        {
                 if( ! strcmp(lppe.szExeFile,"Call_DLL.exe") )
                 {
                   cout<<lppe.szExeFile << "  Prozess ID: "  << lppe.th32ProcessID << endl;
                   break;
                }
        }
        while ( Process32Next ( snap , &lppe ) == 1 ) ;

return lppe.th32ProcessID;
}

@ Martin
Was ich nun wirklich machen will?
Immer wenn ich irgendwas sehe was ich interessant finde beschäftige ich mich gerne damit, ich wollte letzdens etwas mit WriteProcessMemory rumspielen und da bin ich auf ein kleines Problem gestoßen was ich jetzt aber wohl gelöst habe.
Jetzt bin ich erst mal zufrieden und ich habe wieder etwas neues gelernt.

Mir ist gerade noch was aufgefallen bei meiner frikelei habe ich in RetProcessID geschrieben:

CreateToolhelp32Snapshot( TH32CS_SNAPALL, 0 );

Obwohl CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 ); ja "reichen" würde.

Kann man das so sagen oder ist da kein Performance unterschied zwischen:

CreateToolhelp32Snapshot( TH32CS_SNAPALL, 0 ); und CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );

Bei TH32CS_SNAPALL muss die Funktion ja intern an eine andere Stelle springen als bei TH32CS_SNAPPROCESS

Ich glaube ich debugge die Funktion mal aus spaß.