Luckies "myIsDebuggerPresent" liefert immer true

[himitsu]

Mehrere Verschiedene verbauen, am Bestens noch direkt im Code und nicht immer nur die selbe Funktion aufrufen.

So ist es schwerer diese Funktion zu entdecken und auszuschalten.

Wenn alle nur die selbe Funktion nutzen würden, dann könnte man einfach ein Programm schreiben, was die entsprechenden Bytecodes sucht und löscht.
Also praktisch wirkungslos.

PS: Diese Funktion gibt es auch direkt als API, welche man abfragen kann:
http://msdn.microsoft.com/en-us/library/ms680345.aspx
(aber als Anti-Cracking ist es nicht geeignet)

PSS: Rate mal wo Luckie "seine" Funktion her hat?
IsDebuggerPresent ... in den Threads stehen dann auch noch interessante Sachen.

[TheMiller]

Danke euch allen und dir himitsu.

Den Thread habe ich schon gelesen^^

Ich werde die anderen Codes auch einbauen. Auf die Idee wäre ich nicht gekommen. Habe auch Luckie schon Bescheid gesagt, dass er in seinem Artikel das Result vergessen hat. Vielleicht nimmt er die 3 anderen Codes ja mit auf...?

Danke

[mleyen]

Könnte man das asm-geraffel eigentlich irgendwie in Delphicode umschreiben?
Dann könnte man doch inline; hinten dransetzten und man hat dann den Code automatisch mehrmals fest in der Echse drin.

[Neutral General]

Zitat:

Zitat von mleyen

Könnte man das asm-geraffel eigentlich irgendwie in Delphicode umschreiben?
Dann könnte man doch inline; hinten dransetzten und man hat dann den Code automatisch mehrmals fest in der Echse drin.

Nein das geht nicht. Du musst diesen Wert hier auslesen:

Delphi-Quellcode:

mov eax, fs:[$18]

Also fs:[$18]. Das funktioniert mit Delphi nicht, weil man mit normalen Pointern keinen Zugriff auf das fs-Segment hat.

[mleyen]

Hmmm, schade, d.h. es gibt für mich immer noch nichts verständliches / modifizierbares. :duck:

Hier noch einmal ein paar Alternativen die ich mir einmal notiert und getestet habe:
Die meisten Funktionen scheinen relativ gleich zu sein. Soweit ich weiß, sind alle Codes von brechi

Delphi-Quellcode:

function IsDebuggerPresent1: Boolean; stdcall;
asm
  MOV     EAX, DWORD PTR FS:[$30]
  TEST    EAX, EAX
  JS      @@W9X
@@WNT:
  MOV     ECX, FS:[$18]
  MOV     ECX, DWORD PTR [ECX+$30]
  XOR     EAX, EAX
  MOV     AL, BYTE PTR [ECX+2]
  RET
@@W9X:
  MOV     EAX, DWORD PTR [$BFFC9CE4]
  MOV     ECX, DWORD PTR  [EAX]
  CMP     DWORD PTR DWORD PTR [ECX+$54], 1
  SBB     EAX, EAX
  INC     EAX
  RET
end;

function isDebuggerPresent2: Boolean; stdcall;
asm
  MOV     EAX, DWORD PTR FS:[$30]
  TEST    EAX, EAX
  JS      @@W9X
@@WNT:
  MOV     EAX, FS:[$18]
  MOV     EAX, [EAX+$30]
  MOVZX   EAX, [EAX+2]
  RET
@@W9X:
  MOV     EAX, [$BFFC9CE4]
  MOV     ECX, [EAX]
  CMP     DWORD PTR [ECX+$54], 1
  SBB     EAX, EAX
  INC     EAX
  RET
end;

function IsDebuggerPresent3: Boolean; stdcall;
asm
  MOV EAX, FS:[$18]
  MOV EAX, [EAX+$30]
  //MOVZX EAX, [EAX+2]
  DB $0F, $B6, $40, $02
end;

function isDebuggerPresent4: Boolean; stdcall;
asm
  MOV     EAX, FS:[030H] 
  TEST    EAX, EAX 
  JS      @@W9X 
@@WNT: 
  MOV EAX, FS:[$18]
  MOV EAX, [EAX+$30]
  MOVZX EAX, [EAX+2]
  RET
@@W9X:
  MOV EAX, [$BFFC9CE4]
  MOV ECX, [EAX]
  CMP [ECX+$54], 00000001
  SBB EAX, EAX
  INC EAX
  RET
end;

{*----------------------------------------------------------------------------------------
Mehrere isDbbgrPresents zusammengefasst, in der Hoffnung das es mehr bringt ;-O
----------------------------------------------------------------------------------------*}
function isDebuggerPresent: Boolean; inline;
begin
  Result := IsDebuggerPresent1 or IsDebuggerPresent2 or IsDebuggerPresent3 or IsDebuggerPresent4;
end;

[p80286]

Dumme Frage eines ASM-Legasthenikers:

Delphi-Quellcode:

function IsDebuggerPresent3: Boolean; stdcall; 
asm 
  MOV EAX, FS:[$18] 
  MOV EAX, [EAX+$30] 
  //MOVZX EAX, [EAX+2] 
  DB $0F, $B6, $40, $02 
end;

DB $0F, $B6, $40, $02
ist das nicht das gleiche wie MOVZX EAX [EAX+2] ?

Gruß
K-H

[Luckie]

Nein, der Code ist ursprünglich von Oliver.

@DJ-SPM: Wenn du schon nur kopierst, dann bitte auch richtig. Dein Code:

Delphi-Quellcode:

function MyIsDebuggerPresent: Boolean; assembler;
var
  BeingDebugged: Boolean;
begin
  asm
   push eax;
   push ebx;
   mov eax, fs:[$18];
   mov ebx, [eax+$30];
   mov eax, [ebx+2];
   mov [BeingDebugged], al;
   pop ebx;
   pop eax; // Wichtig! POP immer in umgekehrter Reihenfolge von PUSH
  end;
end;

Mein Code:

Delphi-Quellcode:

function MyIsDebuggerPresent: Boolean; assembler;
asm
  mov eax, fs:[$18];
  mov eax, [eax+$30];
  movzx eax, byte ptr [eax+2];
end;

Du hast da alles durcheinander geworfen, was man durcheinander werfen kann. Bei dir wird das Ergebnis in der Variablen BeingDebugged abgelegt. Da sie aber lokal ist, ist deren Inhalt nach Verlassen der Funktion ungültig.

Die globale Variable BeingDebvuggt wird nur benötigt, wenn man den ASM-Code nicht in eine Funktion packt, sondern "nackt" in den Code kopiert, damit man keine verdächtigen Funktionsaufrufe hat.

Also lese den Artikel noch mal sorgfältig.

[himitsu]

Zitat:

Zitat von Luckie

Nein, der Code ist ursprünglich von Oliver.

Und er hatte es damals in der DP rumgepostet :roll:

Zitat:

DB $0F, $B6, $40, $02
ist das nicht das gleiche wie MOVZX EAX [EAX+2] ?

Jupp, das ist mal wieder die beliebte Falle:
Es ringt nix, wenn man etwas im Quellcode "verschlüsselt", was aber nach dem Compilieren wieder "entschlüsselt" ist.

'abc' = #97#98#99 ist genau das Selbe ... es ist zwar jeweils eine andere Quellcode-Darstellung, aber hat Beides das selbe Compilierungs-Ergebnis.

[TheMiller]

@Luckie: Wieso habe ICH alles durcheinander geworfen? Ich hab von anfang an gesagt, dass ich kein Stück assembler beherrsche. Den Code, den ich gepostet habe, habe ich aus DEINEM Artikel von deiner Homepage (siehe hier).

Ich mach dir damit keinen Vorwurf - ich kann ASM nicht. Doch bin gewillt es zu lernen und zu verstehen. Das dauert aber länger, als die Grundlagen von ASM zu lernen - gerade im Anti-Cracking gebiet.

Ich fühle mich auch etwas angegriffen, wenn du schreibst "Wenn du schon nur kopierst und einfügst..." - ich bin lange genug hier im Forum, damit auch du wissen könntest, dass ich nicht der Typ dafür bin. Und dass ich nicht eine solche Einstellung habe, zeigt auch mein Interesse daran, anderen Leuten und dir zu helfen, indem ich dich per Kontaktformular deiner Homepage auf den "Result-Fehler" hingewiesen habe, damit du es ändern/korrigieren kannst.

Nunja... soviel dazu...

[Luckie]

Du hast ihn eben nicht kopiert. Du hast das:

Delphi-Quellcode:

function MyIsDebuggerPresent: Boolean; assembler;
asm
  mov eax, fs:[$18];
  mov eax, [eax+$30];
  movzx eax, byte ptr [eax+2];
end;

mit dem

Delphi-Quellcode:

var
  BeingDebugged: Boolean;

  asm
   mov eax, fs:[$18];
   mov eax, [eax+$30];
   mov eax, [eax+2];
   mov [BeingDebugged], al
  end;

zusammen geworfen.

Und was steht über den hier geposteten zweiten Codeausschnitt?

Zitat:

Schon besser, aber es geht noch besser. Auch dieser Funktionsaufruf ist mit einem CALL verbunden, den man rauspatchen kann. Deswegen ist es besser die Funktion im Code "hardzucoden"

Das ist also keine Funktion, sondern steht so lose irgendwo im Quellcode, damit der verdächtige Funktionsaufruf wegfällt.

Zitat:

zeigt auch mein Interesse daran, anderen Leuten und dir zu helfen, indem ich dich per Kontaktformular deiner Homepage auf den "Result-Fehler" hingewiesen habe, damit du es ändern/korrigieren kannst.

Du hast mich auf einen Fehler hingewiesen, der keiner ist und nur durch das fehlerhafte Kopieren von dir zustanden gekommen ist.

Falls meine Worte etwas hart waren, bitte ich dies zu entschuldigen.