Simpler PE-Crypter

[mr_emre_d]

Ach ja? Ich dachte mir immer, dass beide im Ram liegen (Programm und Stack).
Wenn das so ist wie du es sagst, ist es wunderlich, dass es überhaupt funktioniert.

MfG

[Apollonius]

Es ist nicht verwunderlich, dass es funktioniert. Windows verwendet Segmentation praktisch nicht, beispielsweise zeigen alle Segmente auf die gleiche Startadresse. ss[eax] ist in diesem Sinne aber erstens irreführend und zweitens kostet es ein Byte im Code. Wenn du nur [eax] schreibst, wird implizit das ds-Segment verwendet und das Segment Override Prefix fällt weg.

[himitsu]

Zitat:

Zitat von mr_emre_d

Zitat:

Zitat von spawn89

Guten Morgen,
Irgendwie verstehe ich den Sinn dieser ganzen Angelegenheit nicht. :duck:
Das einzige, was ich mir vorstellen könnte wäre es, Programme wie "DeDe" auszutricksen, damit man seine Codeinhalte "versteckt". Stimmt das?

Ja so ca :) Der Codeinhalt wird nicht versteckt, sondern verschlüsselt.

die "besseren" Decompiler und Co. lesen eh den "Code" aus'm RAM des laufenden Programms aus.
und um die "einfachen" Decompiler zu ärgern, reicht es schon z.B. einige unwichtige Delphitypische Teile zu löschen/verändern.

Und was z.B. das Speichermanagement und die Virenscanner betrifft ... hier gab's schon öfters mal Theman zu Exe-Packern und so.

[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 :D
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 :D )

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?

[himitsu]

Wenn du deine beiden Ver-/Entschlüsselungscodes in Funktionen verpackst, dann kannst du sie ganz einfach mal nacheinander im Delphi-Debugger über einen Speicherblock jagen und schauen was wann warum schief läuft.

PS:

Delphi-Quellcode:

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

Delphi-Quellcode:

MOV ecx, [eax-1] //Byte Davor speichern
XOR [eax], ecx //Mit ECX entschlüsseln

Wobei du auch von vorne nach hinten gehn kannst.

Delphi-Quellcode:

eax := Startposition
temp := Startwert
loop:
temp2 := [eax]
[eax] := [eax] xor temp
temp := temp2
inc eax
goto loop

PPS: dein Vorgehen ist sogar noch unsicherer
denn alles, bis auf das erste Byte kann ohne Kenntnis des Startwertes (der Verschlüsselung) entschlüsselt werden, da man den Startwert der Entschlüsselung kennt.

OK, bei einer so einfachen Verschlüsselung mit einem 1 Byte-Schlüssel braucht man eh nur durchschnittlich 128 Versuche und man hat es auch so entschlüsselt.

[Aphton]

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

Das kann zunächst einmal an folgendem liegen:

1. du packst in EDX die absolute Adresse rein - du solltest aber mit Relativen arbeiten -> ImageBase + relative Adresse
Da die ImageBase von Windows PE Loader geändert werden kann und somit die Image an einem ganz anderen Ort liegt

2. fügst du deinen Stub wirklich in ein Cave und überschreibst keine wichtigen Daten bzw. hat es so funktioniert, wie du es von meinem Tutorial übernommen hast?!

[Luckie]

Zitat:

Zitat von Aphton (Beitrag 1108619)

Da die ImageBase von Windows PE Loader geändert werden kann und somit die Image an einem ganz anderen Ort liegt

Was aber bei einer Exe sehr unwahrscheinlich ist.

[Aphton]

Ja aber halt für alle Fälle...

[Xen]

@himitsu
Wow, der Code fürs vorwärts entschlüsseln ist ja nochmal deutlich kürzer!

Zum Rückwärtscode:
Kann man das denn überhaupt so schreiben???

Code:

MOV ecx, [eax-1] //Byte Davor speichern
XOR [eax], ecx //Mit ECX entschlüsseln

[eax-1] Sieht irgendwie so "Delphisch" aus. Ich hab gedacht jede Arithmetik Operation muss man extra angeben (w.z.B. DEC oder INC)



@Aphton:
1. Ja ich verwende die relative Andressen. Also immer ImgBase + VAddr für den Start, und ImgBase + VAddr + VSize fürs Ende.
Also exakt wie im Tutorial beschrieben.

2. Zum Cave. Ja ... der wird mit 100% Sicherheit hinter das letzte beschriebene SectionByte gesetzt. Also wirklich da wo vie V.Size endet.
Das ganze habe ich mehrmals im Hex-Editor überprüft.


Um zu überprüfen das es am ASM Code liegen muss, habe ich das Ganze (also En/Decrypter) in die Unit aus dem Tutorial verfrachtet.
Mit selben Ergebnis: Exe Kaput bei meinem ASM Code. Exe heil bei mr_emre_d's Original ASM Code.

:cry:

Ist denn der ASM Code wie ich ihn gepostet habe von der Logic u. Syntaktik korrekt?
Da der hier angebotene ASM Crashkurs nicht allzuumfangreich ist habe ich mir vieles einfach zusammen gereimt.
War ich denn richtig der Annahme das "[eax]" auf den Inhalt der Adresse die in eax selbst gespeichet ist zugreift?


Was mir Wahrscheinlich extrem helfen würde wäre den decrypting Prozess in der "Ziel-Exe" direkt im Ram verfolgen zu können.
Wie kann ich das bewerkstelligen? Kann ich für sowas den Delphi Debugger nehmen oder lieber einen externen wie OllyDBG?


Schonmal vielen lieben Dank für die Hilfe!

[Aphton]

Zitat:

Ist denn der ASM Code wie ich ihn gepostet habe von der Logic u. Syntaktik korrekt?
Da der hier angebotene ASM Crashkurs nicht allzuumfangreich ist habe ich mir vieles einfach zusammen gereimt.

Falls ich morgen Lust habe, helfe ich dir. Bin momentan zu Müde dafür.

Zitat:

War ich denn richtig der Annahme das "[eax]" auf den Inhalt der Adresse die in eax selbst gespeichet ist zugreift?

Ja

Zitat:

Was mir Wahrscheinlich extrem helfen würde wäre den decrypting Prozess in der "Ziel-Exe" direkt im Ram verfolgen zu können.
Wie kann ich das bewerkstelligen? Kann ich für sowas den Delphi Debugger nehmen oder lieber einen externen wie OllyDBG?

Codestelle markieren (Breakpoint setzen) und dann in den CPU - Modus/Ansicht wechseln (STRG+SHIFT+C) und per F7 Stück für Stück durchsteppen!
Ollydbg. wäre natürlich noch angenehmer, aber da muss man zuerst einmal die Stelle finden, was für Anfänger nicht so einfach ist.