1. Accueil
  2. C / C++ / C++.NET
  3. Sources C / C++ / C++.NET
  4. Sources Divers
  5. Binder d'exe de débutant

Binder d'exe de débutant

Soyez le premier à donner votre avis sur cette source.

Vue 12 713 fois - Téléchargée 1 104 fois

Télécharger le projet
Commenter

Description

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);


  • taille=ftell(f);

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 =)
Télécharger le projet

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Signaler
Messages postés
475
Date d'inscription
jeudi 19 juin 2003
Statut
Membre
Dernière intervention
3 novembre 2008
Ok merci, je vois plus clair.
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 :)
Signaler
Messages postés
21041
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
 28
Pas du tout, le loader ne lit pas un exe comme un quelconque fichier.
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.
Signaler
Messages postés
475
Date d'inscription
jeudi 19 juin 2003
Statut
Membre
Dernière intervention
3 novembre 2008
Oui, sauf que le fichier au quel on colle des octets à la fin est un executable (assez délicat). Le format(age) de l'exe est d'une certaine manière compromis. Un futur loader des applications win32 peut décider d'interrompre le chargement de l'exe s'il trouve que sa taille ne concorde pas avec celle indiquée (j'imagine qu'il y a un tel champ) dans le header PE (pour je ne sais quel raison).
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.
Signaler
Messages postés
21041
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
 28
Sans tenir compte du code de la source que je n'ai pas lu entièrement mais juste sur le principe, il n'y a aucune raison que ça ne fonctionne pas, le format PE n'entre pour rien dans l'affaire.
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.
Signaler
Messages postés
475
Date d'inscription
jeudi 19 juin 2003
Statut
Membre
Dernière intervention
3 novembre 2008
Je suis surpris que ce programme fonctionne. Vous ajoutez simplement deux fichiers .exe à la fin d'un autre fichier .exe (le binder) en prenant soin de spécifier la taille avant.
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());
Afficher les 12 commentaires
S'inscrire maintenant

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.

Du même auteur (TorTukiTu)