Builder mit Stub, wie?

Ja, aber wenn es nur eine Standalone-Exe wäre, würde das alles viel schöner machen

Solche Stubs werden häufig von Trojaner-Clients (also die eigentlichen Server) erstellt, wo dann die Parameter und die IP hinein geschrieben werden, und ich würde gerne wissen, wie man das macht, in Exen hineinschreiben.
Ich finde das irgendwie lustig

So müsste man bei Programmen, die z.B. eine URL in einem String haben, den String nicht ändern und das Programm neu kompilieren, da man direkt einen Builder dafür bauen könnte.
Klar könnte man den Inhalt des String auch aus einer Textdatei oder einer Textbox lesen, aber ich würde sehr gerne wissen, wie das mit einer Stub funktioniert..

^^
einfach mit FILE*-funktionen die daten ans ende der exe anhängen. die exe muss nur wissen, in welcher reichenfolge welche daten ihr anhängen. dann kann sie sich selber öffnen und die daten auslesen usw.

Dabei wird die Exe nicht beschädigt?

optixx schrieb:

Dabei wird die Exe nicht beschädigt?

nö, du überschreibst ja nix. die exe wird nur grösser

Versucht das System dann nicht die anhängenden Daten auszuführen?
Hm.. ist eine ausführbare Datei, die gerade ausgeführt wird, nicht schreibgeschützt?

markusrw

Skeptiker schrieb:

Versucht das System dann nicht die anhängenden Daten auszuführen?
Hm.. ist eine ausführbare Datei, die gerade ausgeführt wird, nicht schreibgeschützt?

Nope.
Du musst dir das so vorstellen, dass das PE-Format(also exe-dateien) einen Exeheader haben, in denen wichtige Informationen stehe, wie zum Beispiel der Entrypoint(bspw. #445546).
Nun beim ausführen wird dort hingeschprungen und strukturiert die Befehle abgearbeitet. Ob nun was am Ende der Datei steht, was da nicht hingehört, stört ihm erstmal nicht, können ja wichtige Informationen sein, die beim nächsten Start der Exe berücksichtigt werden müssen und vielleicht wäre es zu unsicher diese über die Registry zu schreiben und auszulesen.

Neben dem Anhängen an eine Exe-Datei gibt es noch das direkte überschreiben von Variablenwerten.

#include <whatever>

int main()
{
char[20] ding = "Sind jetzt mal 19 Zeichen + 0-Zeichen";
ostream << ding << endl;
return 0;
}

Nun könntest du über einen Hexeditor oder dem Notepad einfach mal nach dem String in deiner Exe suchen, der so heißt wie oben.
Wenn du keinen bock hast jedesmal was neues dran zu coden, dann änder es über jede Editoren, jedoch muss der bearbeitete String die gleiche Anzahl an Zeichen vorweisen wie der ursprüngliche.

Das hier wäre Beispielsweise eine andere Möglichkeit die Werte auszulesen, die man ans Ende der Datei geschrieben hat:

#include <whatever>

int SoViel = 100;
char& leseZeichenAus(int WieViel);

int main()
{
char* Zeichen = new char[SoViel];
strcpy(SoViel,LeseZeichenAus(SoViel));
....
Auslesen der Werte und Verwertung
....
return 0;
}
char& leseZeichenAus(int WieViel)
{
/*
öffnet die Datei
sprintgt ans Ende dieser
dann rückt der Lesezeiger dann um WieViel zeichen zurück
man liest die Zeichen in eine Variable ein
man schliesst die Datei
man gibt die Variable weiter  
*/
}

Also speichere ich die Datei in Hex-Werten in einer Variable, schreibe diese dann binär in irgendeine Datei und ändere dabei die Werte für den String.

Das hört sich gut an...

Aber was ist, wenn ich da zum Beispiel Passwörter drin speichern will, und die Länge davon variiert... Wie könnte ich das realisieren, wenn sich die Länge des Strings nicht ändern darf...?

kürzer geht ja. den rest füllst du mit dummyzeichen auf.

Wie genau meinst du das?

Soll ich den Rest mit irgendwelchen Zeichen füllen, die ich beim Interpretieren manuell ignorieren soll?

Kann ich da denn nicht einfach Null-Terminierungszeichen hineinschreiben?

glaube, beide varianten würden funzen.