Luckies "myIsDebuggerPresent" liefert immer true

[TheMiller]

Hallo,

ich möchte mich ein bissl mit AntiCracking beschäftigen. Habe jetzt Luckies "AntiCracking"-Artikel gelesen und - weil ich keine Ahnung von ASM habe - voerst einfach per Copy&Paste ins Projekt eingefügt. Beim Programmstart lasse ich mir das Ergebnis anzeigen und erhalte aber immer true - auch außerhalb von der IDE. Was mache ich falsch?

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;

procedure TForm1.FormCreate(Sender: TObject);
var
  ...
begin
  ...

  if (myIsDebuggerPresent) then
    ShowMessage('Ja');

  ...
end;

Ich habe sogar Delphi geschlossen und ich bekomme trotzdem "ja" angezeigt. Vielleicht könnt ihr mir helfen!

Danke im Voraus

[thkerkmann]

Hi,

liefert AX nicht den Rückgabewert einer boolschen Funktion ?

Dann ist push eax - pop eax kontraproduktiv und restauriert eax anstatt das Ergebnis zu liefern.

Vielleicht fehlt da noch ne Zeile, die IsBeingDebugged in AX lädt?

Gruss

[TheMiller]

Ehm...okay...

ich kann echt KEIN asm... garkein bissl... Könntest du mir unter die Arme greigen? Das wäre nett... :zwinker:

[Teekeks]

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;

procedure TForm1.FormCreate(Sender: TObject);
var
  ...
begin
  ...

  if (myIsDebuggerPresent) then
    ShowMessage('Ja');

  ...
end;

[TheMiller]

Hallo,

danke - aber ich erhalte auf die Weise das gleiche Verhalten

[himitsu]

POP EAX würde das Result (welches ja in EAX liegt) überschreiben.

Delphi-Quellcode:

function MyIsDebuggerPresent: Boolean; 
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
  end;
  Result := BeingDebugged;
end;

Delphi-Quellcode:

function MyIsDebuggerPresent: Boolean; assembler;
asm
  push ebx
  mov eax, fs:[$18]
  mov ebx, [eax+$30]
  mov eax, [ebx+2]
  pop ebx
end;

Delphi-Quellcode:

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

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

[TheMiller]

Hi.

Das mit dem "Result" hat funktioniert. Er liefert jetzt die richtigen Ergebnisse. Aber warum hast du noch drei verschiedene Codeblöcke eingebaut? Kannst du dazu noch was sagen?

[rollstuhlfahrer]

die 3 anderen Code-Blöcke sind im Grunde nur Alternativen zu der ersten Funktion. Sie liefern alle exakt das gleiche Ergebnis, nur wird das Ergebnis immer etwas verschieden berechnet.
In der 1. Alternative wird das Ergebnis in ebx berechnet und dann nach eax verschoben und ebx aus dem Stack entfernt.
In der 2. Alternative wird das Ergebnis in edx berechnet und dann nach eax verschoben.
In der 3. Alternative wird das Ergebnis gleich in eax berechnet.

Bernhard

[TheMiller]

Ah okay.

Vielen Dank. Ist irgendeine Methode zu bevorzugen, oder ist es im Grunde egal?

[rollstuhlfahrer]

kommt ganz darauf an, wie du das machen willst. Wenn es etwas unsichtbarer sein sollte, würde ich keine Funktion benutzen, sondern das ganze in der Aufruf-Prozedur machen. Ansonsten sind die 4 gleichwertig.

Bernhard

[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.

[TheMiller]

Ok, das erklärt alles...

Diesen Abschnitt

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"

hatte ich nicht ganz verstanden gehabt. Durch den oberen Abschnitt habe ich angenommen, dass dieser Quelltext auch in eine Funktion gehört. Jetzt, nachdem du mir das eben erklärt hast, weiß ich, dass du mit CALL den Aufruf der Funktion meinst - das klingt jetzt auch logisch. Ich wusste damit heute Morgen/Mittag nix anzufangen.

Gut, dann entschuldige ich mich auch, habe es jetzt verstanden und nehme auch deine Entschuldigung an :cheers:

Achso - und meinen Quelltext werde ich in der Hinsicht auch abändern...

[brechi]

Wenn du glaubst es brignt irgendetwas ggn AntiDebugging -> es bringt rein gar nichts.

[TheMiller]

Nein das glaube ich natürlich nicht. Jetzt kommt wieder - d e r - Satz, der in jedem dieser Threads zu lesen ist:

Klar, alles ist crackbar - aber es sollen wenigesten die Gelegenheitscracker / Kiddies abgehalten werden.

Mehr will ich ja garnicht.

[brechi]

Es wird niemanden abhalten, nicht mal den Gelegenheitscracker. Jedes billige Ollydbg Plugin umgeht das direkt und man kann das Flag auch einfach selbst entfernen.
Man geht unter XP nach $7ffde000 entweder ist das 3. Byte ne 1 oder wenn nicht geht man an die Adresse die bei $7ffde030 steht, dann ist dort das 3. Byte ne 1.
Das setzt man au 0 und schon kann man das Programm debuggen. Und jemand der Debuggen kann (um überhaupt was zu erreichen) der kann Assembler und kann das dann selbst entfernen.

Außerdem hangelst du dir da Probleme ein wenn MS irgendwas ändert (und z.b. der Offset in Win9x auf Rechnern vill China etc. anders ist)

Btw. ist die Aussage mit dem call Schwachsinn, man patched das byte bzw. eben den code direkt. Und wenn du es doch mehrmals im Code verteilen willst nimm dir ne prozedure und markier sie als inline.

[Luckie]

Nun ja, das müsstest du dann mit Oliver klären. Ich habe damit nicht sehr viel Erfahrung.

[TheMiller]

Ehm okay. Ich wusste von der API-Funktion zB nichts. Und ich bin weiß Gott keiner, der keine Ahnung von der EDV etc hat - aber ok, man lernt ja nie aus.

Was könnte man denn machen, um wenigstens die Gelegenheits-Cracker abhalten zu können und so die Raubkopiererei in einem überschaubaren Maß zu halten? Was ist dein Vorschlag?

Wenn du was erklärst, wäre ich froh, wenn du etwas mehr ausholen könntest - wie gesagt, der AntiCracking-Kram ist für mich Neuland. Und das du Ahnung hast musst du nicht unbedingt mit lauter Fremdworten beweisen. Viel besser ist es, wenn du es ausführlich erklären würdest.

Vielen Dank im Voraus und gute Nacht

[himitsu]

Olli hatte aber auch nie gesagt, daß es ein "supersicher" Schutz ist.
Aber es gibt bestimmt so einige "Scriptkiddies" (jaja, es paßt nicht, aber das Wort beschreibt es soooo gut), welche daran scheitern (es sei denn sie sind so intelligent und finden so schöne Erklärungen, wie jetzt bei und hier, wie man etwas umgehnt :roll: )

PS: Im Endeefekt kann man doch alle Anti-Cracking-Maßnahmen umgehen, egal wie gut sie sind,
also wozu überhaupt noch schützen? Schaffen wir einfach Close-Source ab und stellen alles auf OpenSource-Freeware um und schon gibt es keine Probleme mehr.

[schöni]

Zitat:

Zitat von himitsu

Olli hatte aber auch nie gesagt, daß es ein "supersicher" Schutz ist.
Aber es gibt bestimmt so einige "Scriptkiddies" (jaja, es paßt nicht, aber das Wort beschreibt es soooo gut), welche daran scheitern (es sei denn sie sind so intelligent und finden so schöne Erklärungen, wie jetzt bei und hier, wie man etwas umgehnt :roll: )

PS: Im Endeefekt kann man doch alle Anti-Cracking-Maßnahmen umgehen, egal wie gut sie sind,
also wozu überhaupt noch schützen? Schaffen wir einfach Close-Source ab und stellen alles auf OpenSource-Freeware um und schon gibt es keine Probleme mehr.

Erstends kann OpenSource genauso für den unbedarften geschützt sein, denn der Unbedarfte steigt bei der Komplexität dieser Quelltexte nicht durch. Zweitens könnte man bei dieser Sichtweise prinzipiell alle Sicherheitsmaßnahmen abschaffen, da sie ja umgangen werden können.

Fragt sich dann halt nur, wie groß der Aufwand zur Umgehung ist und ob der Craker diesen Aufwand betreiben will.

Wenn jeder Schutz von ClosedSource umgangen werden kann, warum dann überhaupt OpenSource. Der Cracker kann doch den Code so auch bei Closed Souce analysieren, wie er es braucht.

Bei ner 50 Euro Software muss der Schutz weniger aufwendig sein, als bei ner 1000 Euro Software. Bei ner Industriesoftware, wo jede Arbeitsstund bezahlt werden muss, muss ja der illegale Nutzer die Arbeitsstunden für das Cracken bezahlen. Da reicht es, wenn der finanzielle Aufwand zum Crcken den Anschaffungsprei um ein Vielfaches übersteigt. Bei ner Konsumentensoftware muss halt der Aufwand zum Cracken unverhältnismäßig hoch sein bezügleich der benötigten Zeit, gegnüber dem Anschaffungspreis.

Allerdings funktioniert der Zeitschutz (Zeiaufwand zum Cracken) für den Gelegenheitsprogrammierer wegen der Komplexität heutiger OpenSource Programme auch beim OpenSource Konzept. Möglich das beim Profiprogrammierer Komplexe OpenSource Quellen kein wirksamer Schutz sind und der Profi dagegen beim Cracken von Closed Source auch einen ordentlichen Zeitaufwand hat, aber der Zeitaufwand, der zum Cracken nötig ist, entscheidet letztlich darüber, ob der Scutz wirksam ist. Denn wieviel Zeit ist der Cracker letzlich bereit, zu investieren, um das Programm möglichst billig zu kriegen.

Bei OpenSource kommt noch der Aufwand für das Compilieren dazu, wenn es keine vernäünftigen Make Dateien oder Konfigurationsdateien gibt.

[Neutral General]

Zitat:

Zitat von schöni

Erstends kann OpenSource genauso für den unbedarften geschützt sein, denn der Unbedarfte steigt bei der Komplexität dieser Quelltexte nicht durch.

Anmerkung dazu: Jemand der den Anti-Cracking Schutz umgehen kann, wird denke ich auch meistens den Code halbwegs verstehen ;)

[himitsu]

Vielleicht ist es nicht richtig rübergekommen. :angel2:

Es war genau andersrum gemeint...

Zitat:

Zweitens könnte man bei dieser Sichtweise prinzipiell alle Sicherheitsmaßnahmen abschaffen, da sie ja umgangen werden können.

Es kann zwar alles umgangen werden, aber vieles mit etwas Aufwand und auch hier ist es mit etwas Aufwand verbunden, welche "einige" auch genug abschrecken mag.

[cookie22]

hier noch ein paar möglichkeiten:

Delphi-Quellcode:

// Use the API: CheckRemoteDebuggerPresent
function FD_CheckRemoteDebuggerPresent(): Boolean;
var
  Func_Addr: Pointer;
  hModule: Cardinal;
  pDebugBool: PBool;
begin
  result := false;
  hModule := GetModuleHandle('kernel32.dll');
  if hModule = INVALID_HANDLE_VALUE then exit;
  Func_addr := GetProcAddress(hModule, 'CheckRemoteDebuggerPresent');
  if (Func_addr <> nil) then begin
      asm
        lea eax, pDebugBool
        push eax
        push $ffffffff
        call Func_addr
        cmp dword ptr[pDebugBool], 0
        jne @IsDebug
        jmp @exit
      @IsDebug:
        mov @result, 1
      @exit:
      end;
  end;
end;

// Use ntdll_NtQueryInformationProcess () to query
// ProcessDebugPort can be used to detect anti-debugging
function FD_NtQueryInfoProc_DbgPort(): Boolean;
var
  Func_Addr: Pointer;
  hModule: Cardinal;
  ReturnLength: PULONG;
  dwDebugPort: PDWORD;
begin
  result := false;
  hModule := GetModuleHandle('ntdll.dll');
  if hModule = INVALID_HANDLE_VALUE then exit;
  Func_addr := GetProcAddress(hModule, 'ZwQueryInformationProcess');
  if (Func_addr <> nil) then begin
      asm
        lea eax, ReturnLength
        push eax                    //ReturnLength
        push 4                      //ProcessInformationLength
        lea eax, dwDebugPort
        push eax                    //ProcessInformation
        push 7                      //ProcessInformationClass
        push $FFFFFFFF              //ProcessHandle
        call Func_addr              //NtQueryInformationProcess
        cmp [dwDebugPort], 0
        jne @IsDebug
        jmp @exit
      @IsDebug:
        mov @result, 1
      @exit:
      end;
  end;
end;

// Check winXp automatically create the "debug object",
// Not open ProcessDebugFlags class, when the debugger is present, it will return false
function FD_NtQueryInfoProc_DbgFlags(): Boolean;
var
  Func_Addr: Pointer;
  hModule: Cardinal;
  ReturnLength: PULONG;
  dwDebugPort: PDWORD;
begin
  result := false;
  hModule := GetModuleHandle('ntdll.dll');
  if hModule = INVALID_HANDLE_VALUE then exit;
  Func_addr := GetProcAddress(hModule, 'ZwQueryInformationProcess');
  if (Func_addr <> nil) then begin
      asm
        lea eax, ReturnLength
        push eax
        push 4
        lea eax, dwDebugPort
        push eax
        push $1F
        push $FFFFFFFF
        call Func_addr
        mov eax, [dwDebugPort]
        test eax, eax
        jz @IsDebug
        jmp @exit
      @IsDebug:
        mov @result, 1
      @exit:
      end;
  end;
end;

// Int3 Detection
function FD_Exception_Int3(): Boolean;
begin
      asm
        mov @result, 0
        push offset @exception_handler //set exception handler
        push dword ptr fs:[0h]
        mov dword ptr fs:[0h],esp
        xor eax,eax       //reset EAX invoke int3
        int 3h
        pop dword ptr fs:[0h] //restore exception handler
        add esp,4
        test eax,eax // check the flag
        je @IsDebug
        jmp @exit
      @exception_handler:
        mov eax,dword ptr [esp+$c]//EAX = ContextRecord
        mov dword ptr [eax+$b0],$ffffffff//set flag (ContextRecord.EAX)
        inc dword ptr [eax+$b8]//set ContextRecord.EIP
        xor eax,eax
        ret
      @IsDebug:
        xor eax,eax
        inc eax
        mov esp,ebp
        pop ebp
        ret
      @exit:
        xor eax,eax
        mov esp,ebp
        pop ebp
        ret
      end;
end;

// Use int 2dh anomaly detection interrupt
function FD_INT_2d(): Boolean;
begin
  try
      asm
        int 2dh
        inc eax //any opcode of singlebyte.
                //;or u can put some junkcode,
                //"0xc8"..."0xc2"..."0xe8"..."0xe9"
        mov @result, 1
      end;
  except
      Result := false;
  end;
end;

[brechi]

Bevor man den Code benutzt sollte man das aber mal in Delphi umschreiben und die Variablen auch richtig setzen sonst kann der Code von Cookie22 böse Sachen machen :)

[schöni]

Zitat:

Zitat von brechi

Bevor man den Code benutzt sollte man das aber mal in Delphi umschreiben und die Variablen auch richtig setzen sonst kann der Code von Cookie22 böse Sachen machen :)

Zum Beispiel was für böse Sachen?

.

[brechi]

Naja zum Bsp. prüfst du bei GetModuleHandle auf INVALID_HANDLE_VALUE, GMH liefert 0 zurück wenns fehlschlägt, IHV ist aber -1
rest stimmt net hatte die Headerbeschreibeung net gesehen