MD5 Hash einer dll errechnen

xenayoo

Hallo,

ich möchte einen MD5-Hash einer dll errechnen. Ich weiß, dass md5 nicht mehr sicher ist und so, aber ich möchte es trotzdem machen. Die MD5-Funktion ist ja teil der Win32API - was ich da noch dazu inkluden muss, weiß ich im Augenblick nicht mehr, aber es war etwas mit crypt. Ich find's schon wieder.

Ich vermute, dass ich die dll mit LoadLibrary() lade. Damit habe ich ein Handle und die dll liegt im Speicher. Was muss ich nun machen, damit die md5-Funktion der WinAPI daraus nun den Hash ermittelt?

Danke schon mal

Jens

BTW: Ich habe auch die Suchfunktion bemüht, nur heute bin ich scheinbar zu dabbisch, den richtigen Suchbegriff einzugeben...

Jonas OSDever

Warum willst du LoadLibrary benutzen?

Ich würd die Datei Memmory-Mapped öffnen und dann halt die MD5-Funktion auf den Speicherbereich loslassen.

merano

MD5-Hash einer dll ? - Also der DLL (Datei) die geladen wird ?

Mit hFile = CreateFile(...) den Handle besorgen und dann

DWORD High, Low = GetFileSize(MF, &High);

wäre man damit eigentlich fertig.

Wenn man die Gröesse die die DLL im Speicher belegt will könnte man wohl auch
das Betriebssystem fragen:

BOOL WINAPI GetModuleInformation( HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb );

typedef struct _MODULEINFO {
  LPVOID lpBaseOfDll;
  DWORD  SizeOfImage;
  LPVOID EntryPoint;
} MODULEINFO, *LPMODULEINFO;

Wenn man also die Startadresse (lpBaseOfDll) und die Länge (SizeOfImage) weiss ...

xenayoo

Hallo Jonas,

das LoadLibrary fiel mir deshalb ein, weil die dll sowieso geladen wird, um eine Funktion zu verwenden. Muss aber nicht.
Da ich noch reichlich wacklig in der WinAPI bin, verstehe ich gerade nicht, was du demit meinst, die Datei 'Memory-mapped' zu öffnen....

Hallo Merano,

Korrekt. Ich bin mir momentan noch nicht im klaren, welche Parameter die MD5-Funktion erwartet, aber ich würde vermuten, dass sie in irgendeiner Form Startadresse und Größe erwartet.

....und Au weia! Vor CreateFile() hab ich mich bis jetzt gedrückt....

Jens

dot

Bedenke, dass die dll, wenn du sie mit LoadLibrary() lädst, in ihrer DllMain() bereits Code ausführen kann, was ein potentielles Sicherheitsrisiko ist und deine md5 Bemühungen vermutlich sinnlos machen würde...

Jonas OSDever

@xenayoo:
Memmory Mapping bedeuted, dass die Datei geöffnet wird und dann in den Speicher gemappt wird. Heißt: Du greifst auf eine Speicheraddresse zu, aber der Zugriff wird in die Datei weitergeleitet (genau genommen ist es noch etwas komplizierter, du greifst auf den Speicher zu und die Daten werden verzögert beim schließen oder beim Aufruf einer bestimmten Funktion (Name fällt mir grad nicht ein) zurückgeschrieben).
Funktionieren tut das mit den Funktionen CreateFile, CreateFileMapping und MapViewOfFile.

Aber wenn du dich schon vor CreateFile zurückschreckst, bin ich mir nicht sicher, ob dir das jetz schon zumutbar ist. LoadLibrary ist wie bereits von dot erwähnt keine gute Lösung.

xenayoo

Hallo, danke für die Hilfe bis jetzt.

Das LoadLibrary() habe ich in einigen Internetbeiträgen so gesehen. Jedoch ist die Erklärung von dot einleuchtend und so will ich mich mal an CreatFile()heranwagen. Mein Problem ist halt, dass ich mit den MSDN-Beiträgen oft nach Stunden nur teilweise etwas anfangen kann. Z.B. sieht mein Code bis jetzt so aus:

#include <windows.h>
...... 

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nFunsterStil)

{
HANDLE hFile;

    hFile = CreateFile("AvgRa32.dll",   // Filename
                       GENERIC_READ,    // Zugriffsmodus
                       FILE_SHARE_READ, // auch andere können die Datei Lesen
                       NULL,            // Sicherheitsattribute
                       OPEN_EXISTING,   // existierende Datei öffnen
                       0,               // Flags und Attribute
                       NULL);           // Handle zu einer Schablonendatei...

    if(hFile != INVALID_HANDLE_VALUE)
    {
        DWORD dwFileSize;
        dwFileSize = GetFileSize( hFile, NULL);
        if(dwFileSize != 0xFFFFFFFF)
        {
            .....
        }
    }
    CloseHandle(hFile);
}

Ich darf mal an dieser Stelle auf meine Verwendung von GetFileSize hindeuten. Das sieht etwas anders aus.

DWORD dwHigh, dwLow;
dwLow = GetFileSize( hFile, &dwHigh);

Ich habe zwar schon gelesen, dass es da wohl zwei unterschiedliche Angaben (High und Low) gibt, aber ich kann nichts damit anfangen.

Frage ist jetzt: Wie geht es weiter? Ich habe einmal das Hndle hFile und je nachdem welche Variante ich nehme entweder nur den Low-Wert in Bytes oder den Low-Wert und den HighWert. Wenn ich das richtig verstehe, benötige ich noch die Startadresse im Speicher. Dafür muss die dll nicht nur geöffnet sondern auch geladen werden....

Jens

merano

xenayoo schrieb:

Ich habe zwar schon gelesen, dass es da wohl zwei unterschiedliche Angaben (High und Low) gibt, aber ich kann nichts damit anfangen.

Die beiden ergeben zusammen die Länge bei sehr grossen Dateien

ULARGE_INTEGER zahl;
 zahl.LowPart   =  highpart;   
 zahl.HighPart  =  lowpart;

Für kleine Dateien kannst Du es so lassen wie es ist.

Den Anfang hast Du ja jetzt schon, einfach nach Anleitung weitermachen:
http://msdn.microsoft.com/en-us/library/windows/desktop/aa366542(v=vs.85).aspx

merano

Wenn man es einfach nur verwenden will geht auch:

http://msdn.microsoft.com/en-us/library/windows/desktop/aa382380(v=vs.85).aspx

So ein geschiss für eine DLL zu hashen... hajaiai

Jonas OSDever

_hmmm schrieb:

So ein geschiss für eine DLL zu hashen... hajaiai

Besseren Vorschlag?

merano

Jonas OSDever schrieb:

Besseren Vorschlag?

Da es sich vermutlich eher um eine kleinere Datei handelt, die zudem nur einmal
zum Prozessstart getestet werden soll (und dann nie mehr) ist es wohl
tatsächlich ok die Datei zu öffnen, die Grösse zu ermitteln und dann alles als
Block in den Speicher zu laden.

1. CreateFile   (alias OpenFile)
  2. GetFileSize
  3. GlobalAlloc
  4. ReadFile
  5. CloseHandle
  6. Prüfsumme berechnen
  7. GlobalFree

Also das Beispiel von Microsoft mit dynamisch allokiertem Speicher.

xenayoo

_hmmm schrieb:

So ein geschiss für eine DLL zu hashen... hajaiai

Für jemanden, der alles kann und weiß ist das sicher alles 'geschiss'. Ich will damit primär etwas lernen. Ich hoffe, du erlaubst mir das, Danke.

xenayoo

Da es sich vermutlich eher um eine kleinere Datei handelt, die zudem nur einmal
zum Prozessstart getestet werden soll (und dann nie mehr) ist es wohl
tatsächlich ok die Datei zu öffnen, die Grösse zu ermitteln und dann alles als
Block in den Speicher zu laden.

1. CreateFile   (alias OpenFile)
  2. GetFileSize
  3. GlobalAlloc
  4. ReadFile
  5. CloseHandle
  6. Prüfsumme berechnen
  7. GlobalFree

Also das Beispiel von Microsoft mit dynamisch allokiertem Speicher.[/quote]

Dazu hätte ich zwei Fragen:
Zum einen Was sind kleine Dateien bzw. ab wann spricht man von großen Dateien? (Ich vermute die Grenze liegt hier im maximalen Wert von DWORD -> 4.294.967.295).
Die zweite Frage: Wie würde man es denn mit großen Dateien machen? Häppchenweise laden?

Danke und schönes Wochenende
Jens

merano

xenayoo schrieb:

Dazu hätte ich zwei Fragen:
Zum einen Was sind kleine Dateien bzw. ab wann spricht man von großen Dateien? (Ich vermute die Grenze liegt hier im maximalen Wert von DWORD -> 4.294.967.295).

Das muss man wohl relativ zu den vorhandenen Resourcen sehen.
dabei sollte man natürlich nicht von seinem möglicherweise gut ausgestatteten
Entwicklersystem ausgehen sondern von dem System was man als Minimum-Anforderung
definiert.

Dabei ist zu unterscheiden ob die Daten auf dem Stack, auf dem Heap auf einem
deutlich langsameren Ort (Festplatte, NAS, ..) liegen sollen oder können.

Wenn man von einem 32Bit Prozess ausgeht würden tatsächlich Dateien von mehr als 4GB nicht mehr am Stück nutzbar sein, da ein Pointer ja bekanntlich nur 32Bit lang ist.

Unter Windows XP (mit 32 bit) hat das ganze System insgesammt weniger als 4GB
physikalischen Speicher zu Verfügung. Das System würde also relativ schnell
Teile auf die Festplatte auslagern.

xenayoo schrieb:

Die zweite Frage: Wie würde man es denn mit großen Dateien machen? Häppchenweise laden?

Wenn man davon ausgeht das man einen 64Bit (oder mehr) Prozess hat und genügend
Arbeitsspeicher, könnte man alles "am Stück" verarbeiten.

Bei sehr grossen Dateien wäre es wohl besser (notwendig) die Daten in Blöcken
zu verarbeiten. Dabei ist es egal ob man eine Datei mit ReadFile() fortlaufend
liest oder den View auf einem MemoryMapped File verschiebt [MapViewOfFile()].

Im Fall einer DLL ist aber vermutlich die Datei eher klein (wenige kByte).