Petit code sans prétention qui permet de créer un exécutable à partir de deux autres .exe . Lors de la copie, des octets inutiles sont ajoutés, ce qui permet de changer la signature des exécutables. Le produit final est un executable qui est capable d'extraire et d'executer les 2 binaires d'origine. Ne soyez pas méchants avec ma source please =) merci ^^
Source / Exemple :
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <assert.h>
/*-------------Self unpacker by t0rtK ---------------------------
il copie 2 exe (ou n'importequoi)l'un a la suite de l'autre en
rajoutant une entête Celle ci extrait les exe et les execute.
J'ai rajoute une option permettant de rajouter des octets bidons afin que
la signature des exe ne soit plus identifiable avant l'extraction.
-----------------------------------------------------------------
Source simple de debutant postee uniquement en tant qu'exemple
-----------------------------------------------------------------*/
unsigned long* taille(char *file_name);
void file_copy(char *file_name);
void forma(char* binded_name, unsigned long* taille_file1, unsigned long* taille_file2);
int main(int argc, char **argv)
{
FILE *del;
char *file1_name=calloc(256,sizeof(char));
char *file2_name=calloc(256,sizeof(char));
char *binded_name=calloc(256,sizeof(char));
unsigned long *taille_file1;
unsigned long *taille_file2;
del=fopen("tmp.exe","wb");
fclose(del);
if(argc != 4)
{
printf("Syntaxe: binded_name.exe file1.exe file2.exe");
exit(12);
}
file1_name=argv[2];
file2_name=argv[3];
binded_name=argv[1];
taille_file1=taille(file1_name);
taille_file2=taille(file2_name);
file_copy(file1_name);
file_copy(file2_name);
forma(binded_name, taille_file1, taille_file2);
return 1;
}
/*Fonction qui renvoie la taille d'un fichier*/
unsigned long *taille(char *file_name)
{
FILE *f;
unsigned long* taille=calloc(1,sizeof(unsigned long));
f=fopen(file_name,"rb");
assert(f);
fseek(f,0,SEEK_END);
fclose(f);
return taille;
}
/*Fonction qui copie le contenu d'un fichier au bout d'un fichier tampon*/
void file_copy(char *file_name)
{
char *c=calloc(1,sizeof(char));
/*Je sais, j'ai la manie de mettre des calloc dans tous les sens ^^*/
FILE *f_source;
FILE *f_temp;
f_source=fopen(file_name,"rb");
f_temp=fopen("tmp.exe","ab");
assert(f_source);
assert(f_temp);
fseek(f_temp,0,SEEK_END);
while(!feof(f_source))
{
fread(c,sizeof(char),1,f_source);
fwrite(c,sizeof(char),1,f_temp);
}
free(c);
fclose(f_source);
fclose(f_temp);
}
/*Fonction qui crée une entête qui construit l'exe final a partir des differents blocs*/
void forma(char* binded_name, unsigned long* taille_file1, unsigned long* taille_file2)
{
FILE *f;
FILE *h;
FILE *t;
char *c=calloc(1,sizeof(char));
char *v=calloc(1,sizeof(char));
f=fopen(binded_name,"wb");
h=fopen("header.bin","rb");
assert(f);
assert(h);
while(!feof(h))
{
fread(c,sizeof(char),1,h);
fwrite(c,sizeof(char),1,f);
}
printf("taille_header=%lu\n",ftell(f));
/*Permet de connaitre la taille du header, si vous vouliez modifier le code.*/
fwrite(taille_file1,sizeof(unsigned long),1,f);
fwrite(taille_file2,sizeof(unsigned long),1,f);
/*Fin de la creation de l'en tete
Copions a present notre segment de donnes*/
t=fopen("tmp.exe","rb");
assert(t);
while(!feof(t))
{
fread(c,sizeof(char),1,t);
fwrite(c,sizeof(char),1,f);
fwrite(v,sizeof(char),1,f);
}
free(c);
free(v);
/*Voici comment se presente le fichier
|----"self-extractor"----|---donnes sur la tailles des exe --|--------EXE1------|-------EXE2------|*/
}
Conclusion :
Voila, j'espère que ça pourra être utile a quelqu'un. J'ai regardé sur le site, il semble y avoir une source qui y resemble mais celle-ci ne permettait pas de changer la signature (enfin si une signature est bien ce que je crois lol ^^). Je n'ai affiché qu'une partie du code cf. rar pour les autres fichiers =)
26 mai 2008 à 19:08
Y a ce site que j'ai trouvé qui explique le principe graphiquement :
http://dn.codegear.com/article/27979
Apparemment, ça pourrait même fonctionner sous Linux :)
26 mai 2008 à 19:02
Va lire les specs du format PE, tu verras que ne sont lus que les octets utiles définis dans les structures internes, tout ce qui est au delà est ignoré.
Cette méthode est très utile par exemple pour embarquer une DLL dans l'exe, on la dépose à l'exécution dans le dossier TEMP et on la supprime en quittant.
26 mai 2008 à 18:55
J'ignore si Microsoft a documenté comme quoi l'ajout de données supplémentaires à la fin d'un fichier executable est permis. S'ils l'ont fait, ça voudra dire qu'ils grantissent que ça ne causera pas de problèmes dans le futur.
26 mai 2008 à 18:46
On colle des octets à la fin d'un fichier (quel qu'il soit) puis un DWORD à la fin indiquant le nombre d'octets, on doit retrouver les octets originaux en les relisant.
26 mai 2008 à 17:48
Je ne connais pas très bien le format .exe de Windows (appelé PE) ni à quel point est documenté, mais est-ce que ce programme ne risque pas de cesser de fonctionner sur des versions futures de Windows?
Il me semble que le moyen le mieux documenté est d'utiliser l'API Win32 pour ce genre de programme auto-extractable (voir UpdateResoource());
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.