Prüfsumme des eigenen Programs im Speicher ermitteln

[Jasmine]

Hallo Liebe Delphi Freunde,

ich möchte gerne eine Prüfsumme meines eigenen Programs im Speicher ermitteln.
Es geht mir nicht darum, wie die Prüfsumme ermittelt wird oder welchen Algo ich
dafür verwenden muss, sondern wie ich herausbekomme wo im Speicher sich mein Program
befindet und wie ich in einer Schleife schnell wie Werte auslesen kann.

Es geht darum zur Laufzeit zu überprüfen, ob mein Programm gepatched oder verändert worden ist.

Habe schon alles durchsucht, aber leider nichts gefunden.

Über jegliche Tips und Hilfestellungen würde ich mich sehr freuen.

Danke....

Jasmine
:cat:

[Olli]

Gepatcht im Vergleich zu was? Das Image sieht im Speicher schonmal anders aus als auf der Platte, das ist hoffentlich klar?!

Das sog. Modulhandle ist die Adresse deines Moduls im Speicher. Die Größe kannst du durch APIs (VirtualQuery/VirtualQueryEx) oder Auslesen des PE-Headers ermitteln. Danach mußt du nur noch sicherstellen, daß du auf alle Speicherstellen Lesezugriff (VirtualProtect/VirtualProtectEx) hast und es würde funktionieren ... Moduladresse in PDWORD casten und DWORD-weise und superschnell auslesen. Kein Problem.

[Jasmine]

Hallo Olli,

danke für die schnelle Antwort.

Es geht mir natürlich nur um den Programspeicher im Vergleich zu einer festen,
vorher ermittelten Prüfsumme des compilierten Programms, also der .exe Datei.

Jasmine

:cat:

[Zacherl]

Hallo,
du könntest die Prüfsumme im Header der EXE unterbringen und dann zur Laufzeit mit der aktuellen Prüfsumme vergleichen. Hier findest du den "DEC Cipher" von Hagen (negaH). Da meine ich war eine große Demo dabei, die auch die Prüfsumme in ihrem eigenem Header speichert.

Florian

[negaH]

Zitat:

es geht darum zur Laufzeit zu überprüfen, ob mein Programm gepatched oder verändert worden ist.

Wenn das OS deine EXE von Platte in den Speicher lädt, dann patcht in fakt das OS dein Image im Speicher. Das OS zerlegt erstmal alle Sektions der EXE und lädt sie in andere, zerlegte Speicherbereiche. Danach patcht es in den Codesegmenten, sogar Resourcen im Speicher zb. die Relokationen. Da diese Relokationen abhängig davon sind WO im Speicher die einzelnen Sections geladen werden, wird je nach aktueller Speicherbelegung anders realokiert.

All dieses verhindert einen einfachen Algorithmus zur Ermittlung einer Prüfsumme zu programmieren. Zudem ist es dann sogar abhängig von der jeweiligen OS Version.

Unveränderlich kann man aber das Image der EXE auf Platte ansehen. Weshalb auch MS die Digitalen Signaturen zum Scutz dieser Images einfach hinten an die EXE dranhängt. Das was du suchst gibt es also schon, Stichwort Codesignaturen.


Gruß Hagen

[Jasmine]

Ui, gar nicht so einfach, wie ich dachte.

Danke für die Tips und Erklärungen.

Werde wohl dann mal versuchen soeine Codesignatur zu erstellen, bzw. eine Prüfsumme der .exe und
dann im laufenden Programm überprüfen, ob die .exe verändert worden ist.

Versuche dann, wie Flo schon meinte, die Prüfsumme im Header unterzubringen oder am Ende der .exe
anhängen.

Jasmine

:hi:

[negaH]

Hänge sie hinten an. Im Header wäre zwar noch platz aber exakt an dieser Stelle würden Viren zb. Manipulationen vornehmen die eventuell deine Signatur zerstören könnten.

Allerdings schützt diese Methode eben nicht vor dem "dynamischen Patchen" durch unbefugte Programme während der Laufzeit.

Gruß Hagen

[PierreB]

Zitat:

Werde wohl dann mal versuchen soeine Codesignatur zu erstellen, bzw. eine Prüfsumme der .exe und dann im laufenden Programm überprüfen, ob die .exe verändert worden ist.

Moin,

genau sowas wollte ich auch machen, hast du es mittlerweile geschafft ?
Oder kann mir jemand anderes Tipps geben wie man sowas sehr einfach realisieren könnte ?

Thx

[PierreB]

Hm, ich such wirklich nach ner ganz einfachen Variante, keiner ne Idee ? :cry:

[Olli]

Zitat:

Zitat von PierreB

Hm, ich such wirklich nach ner ganz einfachen Variante, keiner ne Idee ? :cry:

Die einfachste Variante ist, egal ob im Speicher oder auf Platte, die EXE zu hashen (oder was auch immer) bevor sie läuft. Daran arbeite ich gerade - darf ich aber nicht rausgeben. Das Prinzip wird wohl über einen Treiber laufen - also über ein externes "Programm". Das Programm kann sich selber nie zuverlässig selber prüfen, es sei denn, daß die einzelnen Funktionen markiert sind. Ansonsten besteht nämlich das Problem, daß man schwerlich Funktionen von Variablen unterscheiden kann. Und ein Hash/Prüfsumme (oder was auch immer) über eine Veränderliche (lat. Variable) ist wohl ziemlich aussichts- und sinnlos.

[NicoDE]

Zitat:

Zitat von PierreB

Hm, ich such wirklich nach ner ganz einfachen Variante, keiner ne Idee ? :cry:

- statische Patterns ins Code-Segment einkompilieren (z.B. mit 'asm db')
- im Programm die Prüfsummen über diverse Blöcke berechnen (crc, w.a.i.)
- mit externem Programm nach Patterns suchen und im Image durch valide Daten erseten

[PierreB]

Moin Olli :hi:

Zitat:

darf ich aber nicht rausgeben.

Hm, dass hört sich (jedenfalls für mich) nicht gut an. :mrgreen:

Sowas muss doch irgendwie möglich sein, ich will doch nur meine Anwendung vor Manipulationen schützen... :wall:

@Nico: Hm, vielleicht is das für dich einfach, ich hab davon aber (leider) keine große Ahnung. :(
Hast du da nicht vielleicht mal ein Beispiel für mich ? :stupid:

[Olli]

Zitat:

Zitat von PierreB

Sowas muss doch irgendwie möglich sein, ich will doch nur meine Anwendung vor Manipulationen schützen... :wall:

Ich würde behaupten, daß es quasi-unmöglich ist. Zumindest mit heutigen Mechanismen. Hagen kann dir sicher einiges zum Thema Sicherheit, TCPA usw. erzählen :zwinker:. Das was ich programmier dient im Endeffekt auch einem anderen Zweck ;)

Zitat:

Zitat von PierreB

Hast du da nicht vielleicht mal ein Beispiel für mich ? :stupid:

Delphi-Quellcode:

label Start, End;
begin
  goto StartCode;
  asm
    db $DE, $AD, $BE, $EF
  end;
StartCode:
  Bla();
  Writeln();
  goto EndCode;
  asm
    db $DE, $AD, $BE, $EF
  end;
EndCode:
end;

... nicht getestet. Wahrscheinlich dank little und big endian auch falsch, aber wenn du dann nach $DEADBEEF suchst, hast du einen Anfangs und Endmarker. Aber auch hier gibt es immer Gegenmaßnahmen.

Wie sagt Hoglund so schön in "Rootkits": Der "Angreifer" muß nur über einen Fall nachdenken, der "Verteidiger" über unendlich viele!

[PierreB]

Zitat:

Ich würde behaupten, daß es quasi-unmöglich ist.

Ja, dass hab ich mir schon fast gedacht. ;)

Aber danke für den Beispiel, ich werd mir das mal zu Gemüte führen. :coder: