Hagens Methode eine Datei zu schützen

[jus]

Hi,
Ich bin beim Durchlesen von alten Artikeln auf eine für mich persönlich sehr interessante Methode von Hagen gestossen, ein Programm zu schützen - siehe hier
Als Programmieranfänger würde mich sehr sehr interessieren wie man so was hinbekommt.
Den relevanten Teil markieren mit ASM Anweisung mit "CODESTART" und "STOPCODE" markieren und mit einem externen Programm die passende Stelle dazwischen verschlüsseln, das würde ich noch hinkriegen.

Nun meine Fragen:
-Doch wie kann ich während das Programm läuft, das Programm im Speicher entschlüsseln und die Funktionen darin aufrufen?
-wie kann man das von Hagen genannte "Structured Exception Handling = SEH" realisieren ?



jus

[jus]

*push*

jus

[jus]

Kann mir denn wirklich keiner helfen?

Da es anscheinend niemand interessiert, muß man sich selbst helfen. Die letzten paar Tage habe ich versucht etwas brauchbares in die Richtung zu finden. Nun bin ich auf den Befehl "ReadProcessMemory" und "WriteProcessMemory" gestossen. Vielleicht kann mir diesesmal jemand sagen, ob ich mich auf den richtigen Weg befinde, oder es eine Sackgasse ist.

Nun meine Fragen dazu:

-Kann ich einfach ohne jegliche Vorbereitung einfach den entschlüsselten Programmteil zwischen "CODESTART" und "STOPCODE" mit WriteProcessMemory in meine markierte Programmstelle reinschreiben?
-und wie finde ich die markierte Stelle bei einem laufenden Programm im Speicher?

Vielen vielen Dank für die Antwort im voraus!

jus

[himitsu]

Ich würd mal sagen irgendwie so:

Delphi-Quellcode:

function StartCode: PChar; 
asm 
     MOV  EAX,OFFSET StartMarker 
     RET 
StartMarker: 
     DB   'CODESTART'#0 
end; 

procedure ProtectedCode; 
begin 
.... 
end; 

procedure StopMarker; 
asm 
      DB  'STOPCODE'#0 
end; 

function StopCode: PChar; 
asm 
      MOV  EAX,OFFSET StopMarker + 9 
      RET 
end;

procedure Encode(P: Pointer; Len: Integer);
begin
  //hier halt irgendwie enschlüsseln
end;

Delphi-Quellcode:

// speicher reservieren
P := GetMem(StopCode - StartCode);
// code von der Datei (diese wird ja in deinen RAM gemappt) kopieren
Move(StartCode, P, StopCode - StartCode);
// den code entschlüsseln
Encode(P, StopCode - StartCode);
// entschlüsselten code ausführen
P2 := P + (ProtectedCode - StartCode);
ASM
  CALL &P2
End;
// Speicher wieder freigeben
FreeMem(P);

!!! keine Garantie, daß mein BeispielCode funktioniert, ist halt nur ein grobes Beispiel

[jus]

@himitsu
Zunächst vielen vielen Dank! Leider funktioniert es nicht.
Ich versuche mit Readprocessmemory die CodeStart Stelle bis Stopcode auszulesen.
ReadProcessMemory(HandleWindow,ptr(SpeicherAdresse),buf,CodeGroesse,BytesRead); Das Problem ist nur, dass ich überhaupt nicht weiß, wie ich die Codestart Stelle als SpeicherAdresse für Readprocessmemory finden/übergeben kann.
Ich habe sogar versucht mit folgendes Adresse zu finden. Leider ohne Erfolg.

Delphi-Quellcode:

function CodeGroesse: Integer;
asm
  mov eax,offset StopMarker
  sub eax,offset Startcode;
  ret
end;

function Startmarkierung:DWORD;
asm
  MOV  EAX,OFFSET Startcode
  RET
end;

procedure Speicherauslesen;
//..
begin
//..
  ReadProcessMemory(HandleWindow,ptr(Startmarkierung),buf,CodeGroesse, BytesRead);
//..
end;

jus

[Luckie]

Motzi hatte mal so etwas als Anticrackschutz implementiert. War aber etwas kompliziert. Schreib ihm mal eine PN und weis ihn auf diesen Thread hin. Kan aber sein, dass er nicht gleich antwortet, weil er zur Zeit ziemlich beschäftigt ist.

[jus]

@Luckie
Werde ich machen, vielen Dank für den Tipp!

Ich habe zumindest den ersten Schritt, die markierte Stelle im Speicher zu finden, nun hingekriegt.

Delphi-Quellcode:

procedure StartMarker;
asm
  DB 'CODESTART',0
end;

procedure ProtectedCode;
begin
  showmessage('protected Code wird ausgeführt');
end;

procedure StopMarker;
asm
  DB  'STOPCODE',0
end;

function StopCode: PChar;
asm
  MOV  EAX,OFFSET StopMarker
  RET
end;

function StartCode: PChar;
asm
  MOV EAX,OFFSET StartMarker
  RET
end;

function CodeGroesse: Integer;
asm
  mov eax,offset StopMarker
  sub eax,offset StartMarker;
  sub eax,10
  ret
end;

function Startmarkierung:DWORD;
asm
  MOV  EAX,OFFSET StartMarker
  ADD  EAX,10
  RET
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  ProcessId : DWORD;
  ThreadId : DWORD;
  Dest: TStream;
  ProcessHandle: THandle;
  Buffer: Pointer;
  Size: DWORD;

begin
  ThreadId := GetWindowThreadProcessId(Handle,@ProcessId);
  ProcessHandle := OpenProcess(PROCESS_ALL_ACCESS,False,ProcessId);

  Buffer:=AllocMem(CodeGroesse);
  ReadProcessMemory(ProcessHandle, ptr(StartMarkierung), Buffer, CodeGroesse, DWORD(nil^));

  //Den Buffer in eine Datei speichern zu Testzwecken
  Dest := TFileStream.Create('testpart.bin', fmCreate);
  Dest.WriteBuffer(buffer^, CodeGroesse);
  Dest.Free;

  FreeMem(buffer);
  closehandle(ProcessHandle);
end;

[himitsu]

Wie gesagt, wenn du innnerhalb deines eigenen Programms daten auslesen willst, kannst du das direkt machen und mußt nicht über Read-/WriteProcessMemory gehen.

Delphi-Quellcode:

Var P: Pointer;

P := StartCode;

Du hast also sofort einen Pointer auf den StartCode, welchen man z.B. einfach kopieren könnte

Delphi-Quellcode:

Var P: Pointer;

P := GetMem(StopCode - StartCode + 1);
Move(StartCode, P, StopCode - StartCode + 1);

Und schon hast du eine Kopie des Codes in einen neuen Speicherbereich (P) kopiert und kannst damit machen, was du willst.

z.B. den ausgelesenen Teil wieder entschlüsseln und dann die enthaltene Prozedur aufrufen.
wobei im OriginalCode die Prozedur ProtectedCode ja eine bestimmte Anzahl an Bytes hinter der dem StartCode liegt, also liegt jetzt die entschlüsselte Prozedur die selbe Anzahl Bytes hinter dem StartCode im neuen Speicherbereich, wo du diese nun aufrufen könntest.

ProtectedCode - StartCode = Anzahl der Bytes (Abstand)

Delphi-Quellcode:

Var P, P2: Pointer;

P := GetMem(StopCode - StartCode + 1);
Move(StartCode, P, StopCode - StartCode + 1);
Encode(P, StopCode - StartCode + 1); {Pointer, Length}
P2 := P + (ProtectedCode - StartCode);
ASM
  CALL &P2
End; 
FreeMem(P);

Vergiß aber nicht die Hinweise von Hagen ... es darf nichts in der gesicherten Funktion/Prozedur drin sein, was mit relativen Sprüngen etwas außerhalb versucht anzuspringen, es sei denn du holst dir vorher die direkten adressen und springst diese an (wie hier z.B. die neue Adresse der Prozedure ProtectedCode ermittelt und angesprungen wurde).

[jus]

Zitat von himitsu:

Wie gesagt, wenn du innnerhalb deines eigenen Programms daten auslesen willst, kannst du das direkt machen und mußt nicht über Read-/WriteProcessMemory gehen.

Delphi-Quellcode:

Var P: Pointer;

P := StartCode;

Du hast also sofort einen Pointer auf den StartCode, welchen man z.B. einfach kopieren könnte

Delphi-Quellcode:

Var P: Pointer;

P := GetMem(StopCode - StartCode + 1);
Move(StartCode, P, StopCode - StartCode + 1);

Und schon hast du eine Kopie des Codes in einen neuen Speicherbereich (P) kopiert und kannst damit machen, was du willst.

z.B. den ausgelesenen Teil wieder entschlüsseln und dann die enthaltene Prozedur aufrufen.
wobei im OriginalCode die Prozedur ProtectedCode ja eine bestimmte Anzahl an Bytes hinter der dem StartCode liegt, also liegt jetzt die entschlüsselte Prozedur die selbe Anzahl Bytes hinter dem StartCode im neuen Speicherbereich, wo du diese nun aufrufen könntest.

ProtectedCode - StartCode = Anzahl der Bytes (Abstand)

Delphi-Quellcode:

Var P, P2: Pointer;

P := GetMem(StopCode - StartCode + 1);
Move(StartCode, P, StopCode - StartCode + 1);
Encode(P, StopCode - StartCode + 1); {Pointer, Length}
P2 := P + (ProtectedCode - StartCode);
ASM
  CALL &P2
End; 
FreeMem(P);

@himitsu
Zunächst einmal vielen vielen Dank, dass du mich unterstützt bei meinem Vorhaben.
Ich bin eigentlich nur über ReadProcessMemory gegangen, weil "Move(StartCode, P, StopCode - StartCode + 1)" irgendwie Probleme (Exception wird ausgelöst) bereitet.

Zitat von himitsu:

Vergiß aber nicht die Hinweise von Hagen ... es darf nichts in der gesicherten Funktion/Prozedur drin sein, was mit relativen Sprüngen etwas außerhalb versucht anzuspringen, es sei denn du holst dir vorher die direkten adressen und springst diese an (wie hier z.B. die neue Adresse der Prozedure ProtectedCode ermittelt und angesprungen wurde).

Das mit den relativen Sprüngen wird wohl noch eine Grosse Hürde sein. Aber derzeit suche ich noch eine Methode aus der project1.exe die relevante Stelle zwischen CODESTART und CODESTOP auszulesen.
Ein Problem, das ich auf mich zukommen sehe, ist, dass die Verschlüsselungslänge wahrscheinlich länger sein kann als die ursprüngliche Länge. Das muß ich auch noch irgendwie hinkriegen.
Also wenn jemand zu meinen Problem Lösungsvorschläge weiß, bin ich ganz Ohr.



jus

[negaH]

Zitat:

Ein Problem, das ich auf mich zukommen sehe, ist, dass die Verschlüsselungslänge wahrscheinlich länger sein kann als die ursprüngliche Länge.

Wieso ? Die meisten sicheren symmetrischen Algorithmen können Daten inplaced verschlüsseln. In meinem damaligem Anti-Cracking-Program habe ich direkt nach "CODESTART" noch 256 Bytes an Zufallsdaten eingebettet. Das "Registrationspasswort" ware ebenfalls per Zufall gewählt. Als Verschlüselungsalgo. hatte ich einen modifizierten RC4 benutzt. Suche mal hier in er CodeLib nach RCx.

Ich empfehle dir aber in meinem DEC den IDEA Cipher anzuschauen. Dieser Cipher hat asymmetrische Ver- und Entschlüsselungsfunktionen. Mit asymmetrisch sind nicht die bekannten Verfahren gemeint sondern in diesem Fall der fakt das die Verschlüsselungsfunktion nicht die gleiche ist wie die Entschlüsselungsfunktion, und das im matheamtischen Sinne eine inverse Funktion darstellt die das multiplikative Inverse benötigt. Erwähnen tue ich dies weil du nun zb. IDEA zerpflücken könntest und nur die Entschlüsselungsfunktion in deine EXE integrierst, mit leichten Abwandlungen. Nur wer die Ver-schlüsselungsfunktion dazu kennt kann also auch den Schutz deiner EXE reimplementieren und somit einen echten Keygen programmieren.

Gruß Hagen