Simpler PE-Crypter

[Xen]

Nennt mich ThreadLeichen-Schänder, aber ich hab da mal ne Frage bzw. ein Problem.

Die Sache mit dieser Assembler Stub finde ich unglaublich spannend!
Wegen dem Tutorial hab ich mich gleich auf Assembler gestürtzt
Deswegen wollte ich nicht den selben Code nehmen wie im Tutorial.
Damit ein wenig spannender wird, wollte ich das ganze etwas komplizierter gestalten, nur geht es jetzt nicht mehr :

Nach dem Tut wird jedes Byte der Section mit dem Key geXORed.
(Funktioniert ja auch wunderbar)

Ich wollte das folgendermaßen machen:

Ich Xore das ERSTE Byte der Section mit dem Key (Magic)
Das 2. Byte Xore ich mit dem Ersten (was ja schon mit Magic Xored ist)
Danach Xore ich das 3. Byte mit dem 2.
Danach das 4. mit dem 3.
usw.
bis ich am Ende ankomme.

Funktioniert soweit.

Zum Entschlüsseln gehe ich der Einfachheit halber von hinten nach vorne durch die Section:

Ich nehme das vorletzte Byte und Xore es mit dem Letzten ( = Letztes Byte jetzt im Klartext)
Ich nehme das vorvorletzte Byte und Xore es mit dem vorletzten ( = Vorletztes Byte jetzt im Klartext)
Ich nehme das vorvorvorletzte Byte und Xore es mit vorvorletzten ( = Vorvorletztes Byte im Klartext)
...
Bis ich beim ERSTEN Byte angekommen bin. Das wiederum Xore ich mit dem Key ( = Ganze Section entschlüsselt)

Das ganze habe ich in Assembler geschrieben:

(Alle $1100.. und $00 Adressen werden nacher durch echte Adressen ersetzt)

Delphi-Quellcode:

asm

                MOV eax, $11000000 // ENDE der Section ImageBase + V.Addr + V.Size
                MOV edx, $11000000 // Echter EntryPoint
                DEC eax    // Einen Runter

         @loop: CMP eax, $11000000 // Wenn gößer als der START Imagebase + V.Addr
                JE @lastbyte  // Wenn gleich dann Springen

                  DEC eax       //Zum Byte davor gehen
                  MOV ecx, [eax]  //Byte Davor speichern
                  INC eax       //Wieder zu dem noch verschlüsselten zurück
                  XOR [eax], ecx //Mit ECX entschlüsseln

                  DEC eax       // Wieder aufs vorige Byte zurück
                  JMP @loop

     @lastbyte: XOR [eax], $00  // Letztes byte mit Key entschlüsseln
                JMP edx       // Zum Echten Entry Point springen
end;

Das Funktioniert aber leider nicht. Die Exe ist nacher beschädigt

Hat Irgendjemand ein wenig Ahnung von Assembler und kann mir sagen was ich dort falsch mache?

Die Idee dahinter funktioniert. Ich habe die verschlüsselte Datei mal nacher mit einem "Zeile für Zeile von ASM nach Delphi"-Code entschlüsselt.
Ergebnis: Exe funktioniert. (Ich benutze ein in Delphi geschriebenen Pizza-Timer )

Hier ist der "Zeile für Zeile von ASM nach Delphi"-Code:

Delphi-Quellcode:

                eax := SecEnd;  // ENDE der Section ImageBase + V.Addr + V.Size
                Dec(eax);

          loop: if eax = SecStart then // Wenn gößer als der START Imagebase + V.Addr
                  goto lastbyte;  // Wenn gleich dann Springen

                  Dec(eax);       //Zum Byte davor gehen
                  ecx := FileData[eax];  //Byte Davor speichern
                  Inc(eax);       //Wieder zu dem noch verschlüsselten zurück
                  FileData[eax] := FileData[eax] XOR ecx; //Mit ECX entschlüsseln

                  Dec(eax);      // Wieder aufs vorige Byte zurück
                  goto loop;

    lastbyte:    FileData[eax] := FileData[eax] XOR Magic;  // Letztes byte mit Key entschlüsseln

Wie gesagt hier gings nur darum die Funktion des ASM exakt nachzubilden.
Aber es funktioniert.

Jetzt meine Frage:

Was macht mein "Wannabe"-ASM Code richtig, was mein echter ASM Code falsch macht?