Comme Oli l'a déjà souligné dans sa réponse, vous ne pouvez pas obtenir le code source très original d'un exécutable.
Pendant la compilation d'un code source (compilation conçue comme dans son acceptation plus large typique, donc comme tout le processus qui "transforme" un code source en un exécutable), beaucoup d'informations sont perdues.
Le préprocesseur C, pour sa part, fera ce qui suit (entre autres):
- Interpréter, exécuter et supprimer des directives de préprocesseur (
#instructions)
- Supprimer les commentaires
- Supprimer les espaces inutiles
D'un autre côté, ce qui n'est pas perdu lors de la compilation du code source est techniquement réversible en un code source fonctionnellement équivalent.
Ceci est dû au fait:
- Les instructions binaires ont une correspondance 1: 1 avec les instructions de montage; l'assemblage d'un code source d'assemblage n'est qu'une simple conversion des instructions d'assemblage en instructions binaires sur la base d'un tableau de correspondance; une seule instruction binaire est toujours identifiable et convertible en une seule instruction d'assemblage ;
- Les instructions de montage n'ont pas de correspondance 1: 1 avec les instructions C; la compilation d'un code source C n'est généralement pas seulement une simple conversion des instructions C en instructions d'assemblage basées sur un tableau de correspondance, en fait c'est souvent le contraire; généralement une instruction C est convertie en plusieurs instructions d'assemblage (souvent différentes selon le compilateur); cependant, les modèles d'instructions d'assemblage multiples sont généralement identifiables et convertibles en une seule instruction C ;
Il existe des outils appelés décompilateurs dont le but est d'essayer de rétablir un exécutable en un code source fonctionnellement équivalent; cependant le résultat est généralement quelque chose de loin du code source très original (et généralement aussi incompilable);
Considérez ce programme:
#include <stdio.h>
#define MESSAGE "Literal strings will be recovered" // This preprocessor directive won't be recovered
/*
This comment and the comment above won't be recovered
*/
int main(int argc, char* argv[]) {
printf(MESSAGE);
return 0;
}
En le compilant dans un exécutable et en le décompilant à nouveau dans un code source, c'est plus ou moins ce que vous récupérez habituellement (dans ce cas spécifique, j'ai utilisé gcc/ Boomerang ):
// address: 0x80483fb
int main(int argc, char **argv, char **envp) {
printf("Literal strings will be recovered");
return 0;
}
Comme prédit:
- Les directives du préprocesseur sont manquantes
- Les commentaires sont manquants (à part
// address: 0x80483fb, qui a été ajouté par le décompilateur)
- Espace vide inutile manquant (à part les nouvelles lignes et les tabulations, qui ont été ajoutées par le décompilateur)
C'est aussi un très bon résultat; il n'est pas rare d'obtenir des instructions d'assemblage en ligne dans le code:
asm("assembly_instruction");
__asm__("assembly_instruction");
L'essentiel est (comme déjà souligné dans les autres réponses): vous ne pouvez pas obtenir la source très originale d'un exécutable *.
* Cependant, selon l'exécutable et votre chance, vous pourrez peut- être obtenir quelque chose en utilisant un décompilateur.
stringsprogramme de filtrage peut être très utile pour identifier ce qu'est ou fait un programme binaire particulier car il imprimera toutes les chaînes de texte incorporées plus longtemps qu'une longueur spécifiée dans un fichier binaire et en regardant les messages dans un programme vous en dit parfois beaucoup sur ce qu'il est et ce qu'il fait.