Frage zum Crypten

Hay Leute , also ich fühle mich irgenwie bereit dazu nen Crypter zu schreiben (only Scantime ) ^^ ich wills aufjedenfall mal probieren , ich habe aber noch ein paar Fragen.

Also mit dem Builder Verschlüssele ich die Datei.
In der Stub stehen die Informationen zum entschlüsseln.
Die Stub schreibe ich an das Ende der Datei.
(genau so wie beim Builder ) Also LOF(1) +1) ?

Würde ich das so richtig machen :confused:

mfG

dann entschlüsseln und droppen+executen inner stub

ich lade ja die Datei in ein bytearray.
und das byte array übergebe ich der stub.
Dann lasse ich die Datei aus dem byte array in irgendein Verzeichniss droppen und ausführen .richtig ? ^^

mfG

Zitat:

ich lade ja die Datei in ein bytearray.
und das byte array übergebe ich der stub.
Dann lasse ich die Datei aus dem byte array in irgendein Verzeichniss droppen und ausführen .richtig ? ^^

Theoretisch völlig Korrekt, vergiss allerdings nicht eine paar Zeichen an die Sub zu schreiben, bevor die eigentliche Datei kommt. Damit du weißt wo deine Gecryptede Datei anfängt und aufhört ;)

MfG

Stimmt Splittzeichen ^^

mfG

Zitat:

Zitat von ThePapst

vergiss allerdings nicht eine paar Zeichen an die Sub zu schreiben, bevor die eigentliche Datei kommt. Damit du weißt wo deine Gecryptede Datei anfängt und aufhört ;)

Das weiß man auch so...
Ich hab's schonmal im Experten-Bereich gepostet und poste es hier nochmal:
http://free-hack.com/showthread.php?t=33601

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/*
für die Strukturen in "winnt.h"
*/
#include <windows.h>

int main(void)
{
FILE *fp;
char *buffer;
int sz;
int offset;
IMAGE_DOS_HEADER *idh;
IMAGE_NT_HEADERS *inh;
IMAGE_SECTION_HEADER *ish;

/* Datei öffnen */
if (!(fp = fopen("test.exe", "rb")))
{
puts("Fehler: konnte die Datei nicht öffnen!");
exit(0);
}

/* Dateigröße holen */
fseek(fp, 0, SEEK_END);
sz = ftell(fp);
fseek(fp, 0, SEEK_SET);

/* Speicherplatz reservieren */
if (!(buffer = (char *) malloc(sz + 1)))
{
puts("Fehler: nicht genug Speicher vorhanden!");
exit(0);
}

/* Datei einlesen */
fread(buffer, 1, sz, fp);
fclose(fp);

/* IMAGE_DOS_HEADER zuweisen */
idh = (IMAGE_DOS_HEADER *) buffer;

/* IMAGE_NT_HEADERS zuweisen */
inh = (IMAGE_NT_HEADERS *) &buffer[idh->e_lfanew];

/* den letzten IMAGE_SECTION_HEADER finden */
offset = idh->e_lfanew + sizeof(IMAGE_NT_HEADERS) + (inh->FileHeader.NumberOfSections - 1) * sizeof(IMAGE_SECTION_HEADER);
ish = (IMAGE_SECTION_HEADER *) &buffer[offset];

/* offset zu "EOF" berechnen */
offset = ish->PointerToRawData + ish->SizeOfRawData;

/* offset und "EOF-Daten" ausgeben (falls möglich) */
printf(
"Das Offset zu \"EOF\" beträgt %d Bytes!\n"
"---------------------------------------\n"
"%s\n"
"---------------------------------------\n"
, offset
, &buffer[offset]
);

getc(stdin);
return 0;
}

Auf Deutsch: rein in den PE-Header, die letzte Section finden -> PointerToRawData + SizeOfRawData = eigentliches Dateiende, also da wo normalerweise die Datei bei Scantime-Cryptern hingeschrieben wird.

Jetzt kann man zwar sagen, dass das alles viel zu aufwendig ist, aber da ein VB Scantime-Crypter sowieso maximal aus 20 Zeilen Code bestehen dürfte, sollte ja noch genug Zeit bleiben soetwas zu implementieren.

Zitat:

Zitat von inmate

In der Stub stehen die Informationen zum entschlüsseln.
Die Stub schreibe ich an das Ende der Datei.

Es ist schön für den Stub, wenn er am Ende der Datei steht... ausgeführt wird er dadurch aber nicht... bzw. wenn du die eigentliche Datei verschlüsselst werden die ganzen Prüfsummen bzw. Signaturen (z.B. MZ, PE) zerstört und der Windows-Loader erkennt deine Datei nicht mal mehr als eine PE-Datei...

Es heisst die Stub^^.

Ja stimmt ich lade ja das Bytearray in die Stub, und in der Stub stehen dann ja die Informationen zum Entschlüsseln ;)

mfG

Zitat:

Zitat von inmate

Es heisst die Stub^^.

Viele sagen auch der Exploit... ich sage das Exploit...
w/e - wenn du im Duden "die Stub" findest glaube ich dir. (unwahrscheinlich, oder?)
Wenn nicht schreibe ich es einfach weiterhin so wie ich gerade will ;)

Btw: man kann natürlich von hinten durch die Brust ins Auge stechen (BlackBerrys Methode :D) - aber als ich damals zum ersten mal unbedingt einen Binder schreiben wollte (lang ist es her ;) ), habe ich die ganzen Werte direkt in die Stub geschrieben.
Man definiert halt für die Infos, die man "weitergeben" möchte globale Variablen in der Stub und weist denen schöne auffällige Werte zu (bei Integern z.B &DEADBEEF oder &EBFEEBFE, bei Strings ähnliches). Dann sucht man im Hexeditor nach diesem Muster[1] markiert das erste Byte und merkt sich die Adresse. Im Builder geht man dann eben an diese Postition (sollte in VB SEEK heißen, man sollte bei Gelegenheit auch gleich ein paar Dateihandlingtutorials suchen ;) http://www.dreamincode.net/forums/showtopic56171.htm) und schreibt dann die "richtigen" Werte rein. Z.B kann ja der Builder schon ermitteln
1) wie groß die Stub ist
2) wie groß die angehängte Datei ist
und kann auch gleich sonstige Optionen hineinschreiben.
Nachteil ist eben, dass man nach jeder größeren Änderung der Stub die Adressen nochmal nachschauen muss. Vorteil - sollte am Anfang viel leichter umsetzbar sein, als PE-Gewurschtel (vor allem in VB ;) )

[1]man muss nach den Bytemustern "rückwärts" suchen - also z.B wenn man &DEADBEEF zugewiesen hat, sucht man im Hexeditor nach EF BE AD DE. Oder gleich "einheitliche" Bytes zuweisen: &42424242 - dann kann man direkt nach 42 42 42 42 suchen ;).

Du kannst auch einfach die gecryptete datei als bytecode in die recourse der stub schreiben und dann wieder auslesen. Finde aber bei .NET ist die Methode mit Byte anhängen ziemlich angenehm. :)