CREER UN FAKE CODE ASSEMBLEUR

#include "stdafx.h"
#include <stdlib.h> 
#include <windows.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
//#pragma warning(disable: 4786)
#include <vector>
#include <iostream> 
#include <fstream.h>

//using namespace std;
typedef std::vector<char *> rd;
rd listeregistre;

char registred[6][255]={"eax","ebx","ecx","edx","esi","edi"};
char registres[6][255]={"eax","ebx","ecx","edx","esi","edi"};
char tablefs[9][255]={"0h","1ch","20h","28h","2ch","30h","34h","38h","124h"};
char type[27][9][255]={
		{"push","%s %s %s"," m"," r"," i"," r"," m"," i","90"}, //90 c le pourcentage
		{"mul","%s %s %s","m ","r ","m ","r ","m ","r ","80"}, 
		{"sub","%s %s,%s","mr","rm","rr","ri","mi","rr","85"}, 
		{"and","%s %s,%s","mr","rm","rr","ri","mi","rr","85"}, 
		{"or","%s %s,%s","mr","rm","rr","ri","mi","rr","80"}, 
		{"pop","%s %s","r ","r ","r ","r ","r ","r ","90"}, // on lui interdit les acces memoire
		{"test","%s %s,%s","mr","rm","rr","ri","mi","rr","20"}, 
		{"shl","%s %s,%s","ml","rl","ml","rl","ml","rl","30"}, 
		{"cmp","%s %s,%s","mr","rm","rr","ri","mi","rr","20"}, 
		{"shr","%s %s,%s","ml","rl","ml","rl","ml","rl","30"}, 
		{"mov","%s %s,%s","mr","rm","rr","ri","mi","rf","85"}, 
		{"xor","%s %s,%s","mr","rm","rr","ri","mi","rr","85"}, 
		{"add","%s %s,%s","mr","rr","ri","mi","rm","rr","85"}, 
		{"sal","%s %s,%s","ml","rl","ml","rl","ml","rl","30"},
		{"dec","%s %s","m ","r ","m ","r ","m ","r ","50"}, 
		{"neg","%s %s","m ","r ","m ","r ","m ","r ","60"}, 
		{"sar","%s %s,%s","ml","rl","ml","rl","ml","rl","30"}, 
		{"rol","%s %s,%s","ml","rl","ml","rl","ml","rl","43"},					 
		{"inc","%s %s","m ","r ","m ","r ","m ","r ","50"}, 
		{"not","%s %s","m ","r ","m ","r ","m ","r ","50"}, 
		{"int 3","%s","  ","  ","  ","  ","  ","  ","50"},
		{"je","%s %s","b ","b ","b ","b ","b ","b ","100"},
		{"jne","%s %s","b ","b ","b ","b ","b ","b ","100"},
		{"jb","%s %s","b ","b ","b ","b ","b ","b ","100"},
		{"jbe","%s %s","b ","b ","b ","b ","b ","b ","100"},
		{"jnb","%s %s","b ","b ","b ","b ","b ","b ","100"},
		{"jnbe","%s %s","b ","b ","b ","b ","b ","b ","100"}
}; 

						


int main(int argc, char* argv[])
{
	ofstream sortie;
	int pile=0;
	int ins=0;
	int keltyp;
	int constante=0;
	int valeurpile=0;
	int regd=0,regs=0;
	int fs=0;
	bool trouve;
	char sregd[255],sregs[255],sins[255],label[255],oldins[255],regoqp[255];
	bool interdit;
	int kan;
	

	sortie.open("fakeasm.txt");


interdit=false;
strcpy(label,"");
strcpy(oldins,"");
srand ( time(NULL) );
kan=0;


strcpy(regoqp,""); // indiquer ici le registre que ne doit pas toucher le code
					// si vous ne mettez rien, alors inserer du code en utilisant la pile pour stocke



sortie << "//---------- debut code factice ----------" <<endl;
sortie << "//registre attribue: " << regoqp <<endl;
sortie << "// a mettre entre _asm { }" << endl;
sortie << "// rajouter /Zm400 a la compilation, 400=400% de memoire en + " << endl;
for (int nb=100000;nb>0;nb--) //indiquer le nombre d'instruction mettez en suffisement pour decourager 10000 par exemple
{


	do {
		strcpy(sregd,"");
		strcpy(sregs,"");
		strcpy(sins,"");
		trouve=true;


		ins = rand()%27; 
		if ((!stricmp(&type[ins][0][0],"cmp") || !stricmp(&type[ins][0][0],"test")) && nb < 10 ) continue; // evite les test vers la fin du code
		if (!stricmp(&type[ins][0][0],"pop") && pile<=0) continue; // pas de pop si ya pas eu de pile
		if ((!stricmp(&type[ins][0][0],"cmp") || !stricmp(&type[ins][0][0],"test")) && rand()%10 <8 && !interdit) continue; //evites les test/cmp trop frequent
		if (type[ins][0][0] == 'j' && stricmp(oldins,"cmp") && stricmp(oldins,"test")) continue; // pas de saut si pas preceder de cmp/test
		if (!stricmp(&type[ins][0][0],"pop") && interdit) continue; // pas de pop si on attend une fin de saut 
		if (!stricmp(&type[ins][0][0],"push") && interdit) continue; // pas de push si on attend une fin de saut 
		if (!stricmp(&type[ins][0][0],"cmp") && interdit && kan < 10 ) continue; // pas de cmp si on attend une fin de saut
		if (!stricmp(&type[ins][0][0],"test") && interdit && kan < 10) continue; // pas de test si on attend une fin de saut
		if (type[ins][0][0] != 'j' && (!stricmp(oldins,"cmp") || !stricmp(oldins,"test"))) continue; // on sassure que derriere un cmp/test ya bien un jxx
		
		int pourcentage;
		sscanf(&type[ins][8][0],"%d",&pourcentage);
		if (pourcentage <= rand()%100) continue;
		
		
		if (stricmp(&type[ins][0][0],"pop") && pile>0 && rand()%100 > 80 ) //augmente la frecquence de pop si la pile est trop haute
		{
			if (interdit) continue;
			ins = 5; //on force un pop
		}

		do {
			keltyp= rand()%6;
		}
		while (type[ins][keltyp+2][0] == 'm' && pile==0); // pas de [esp+x] en destination si ya pas eu de pile

		
		// on cree la destination
		if (type[ins][keltyp+2][0] == 'm') { // memoire    [esp+%s] 	
			if (pile>4) valeurpile = rand()%pile;
			else valeurpile=0;

			valeurpile = (valeurpile/4)*4; //on creer un multiple de 4

			if (valeurpile)
				sprintf(sregd,"dword ptr[esp+%d]",valeurpile);
			else
				strcpy(sregd,"dword ptr[esp]");
		}
		else if (type[ins][keltyp+2][0] == 'i') { // constante
			constante = rand()%0x7fffffff;
			sprintf(sregd,"%d",constante);
		}
		else if (type[ins][keltyp+2][0] == 'l') { // constante de 0 a 7
			constante = rand()%7+1;
			sprintf(sregd,"%d",constante);
		}
		else if (type[ins][keltyp+2][0] == 'r') { // registre
			do {
				regd = rand()%6;
			}
			while (!stricmp(regoqp,registred[regd])); // on eviter lecriture dans le registre alloue


			strcpy(sregd,registred[regd]);
		}
		else if (type[ins][keltyp+2][0] == ' ') { // pas de destination
			strcpy(sregd,"");
		}
		else if (type[ins][keltyp+2][0] == 'b') { // label
			if (interdit) {
				strcpy(sregd,label);
			}
			else
			{
				sprintf(sregd,"L%d",nb);
				strcpy(label,sregd);
				kan=rand()%90+10; //nombre d'instruction avant de poser le label
				interdit=true;
			}
		}
		else { //erreur
			continue; // on recree une autre instruction
		}


		// on cree la source
		if (type[ins][keltyp+2][1] == 'm') { // memoire    [esp+%s] 
			if (pile) valeurpile = rand()%pile;
			else valeurpile=0;
			valeurpile = (valeurpile/4)*4; //on creer un multiple de 4
			//valeurpile &= 0xfffffffe; //pour avoir une valeur pair
			
			if (valeurpile)
				sprintf(sregs,"dword ptr[esp+%d]",valeurpile);
			else
				strcpy(sregs,"dword ptr[esp]");

			if (rand()%10 > 5) // pourquoi ne pas essayer de prendre une valeur [esp+x] deja utiliser pour faire plus vrai?
			{
				for (int cel=0;cel<listeregistre.size();cel++) 
				{
					if (!strnicmp(listeregistre[cel],"dword ptr[esp+",14)) { 
						strcpy(sregs,listeregistre[cel]);
						break;
					}
				}
			}


		}
		else if (type[ins][keltyp+2][1] == 'f') { // registre fs
			fs=rand()%9; // si le registre est fs
			sprintf(sregs,"fs:[%s]",&tablefs[fs]);
		}
		else if (type[ins][keltyp+2][1] == 'r') { // registre
			regs = rand()%6;
			strcpy(sregs,registres[regs]);
		}
		else if (type[ins][keltyp+2][1] == 'i') { // constante
			constante = rand()%0x7084fff;
			sprintf(sregs,"%d",constante);
		}
		else if (type[ins][keltyp+2][1] == 'l') { // constante de 0 a 7
			constante = rand()%7+1;
			sprintf(sregs,"%d",constante);
		}
		else if (type[ins][keltyp+2][1] == ' ') { // pas de destination
			strcpy(sregs,"");
		}
		else { //erreur
			continue; // on recree une autre instruction
		}

		trouve=false; // ici on va chercher si la destination a deja ete mise en destination
		if (!stricmp(&type[ins][0][0],"pop") || !stricmp(&type[ins][0][0],"mov")) 
		{
			for (int cel=0;cel<listeregistre.size();cel++) // sans avoir etait passée en source apres
			{
				if (!stricmp(listeregistre[cel],sregd)) { // c'ets valable uniquement parcque mov et pop reecrase
					trouve=true; //completement la destination
					break;
				}
			}
		}
	}
	while (!stricmp(sregd,sregs) || trouve); // evites les ... eax,eax ou si trouve==true


	// cas particuliers
	if (!stricmp(&type[ins][0][0],"pop")) {
		pile-=4;
		for (int cel=0;cel<listeregistre.size();cel++) // on va supprimer tous les [esp+x] avec x> pile
		{
			if (!strnicmp(listeregistre[cel],"dword ptr[esp+",14)) { 
				int pp;
				if (sscanf(listeregistre[cel],"dword ptr[esp+%d]",&pp) != 1) continue; //on se fait pas chier
				if (pp>pile-4) { //-4 par securité
					delete listeregistre[cel];
					listeregistre.erase(listeregistre.begin() + cel);
				}
			}
		}
		
	}

	if (!stricmp(&type[ins][0][0],"push"))
	{
		if (pile >= 100) continue;//on limite la taille de la pile, tampis on saute l'instruction
		pile+=4;
	}


	if (strlen(sregd)) { // on sauve le registre de destination pour les redondances
		trouve=false;
		for (int cel=0;cel<listeregistre.size();cel++) // regarde si deja empile
		{
			if (!stricmp(listeregistre[cel],sregd)) {
				trouve=true;
				break;
			}
		}
		if (!trouve) {
			char *temp=new char[255];
			strcpy(temp,sregd);
			listeregistre.push_back(temp); //on empile pour etre utilisable par la suite
		}
	}

	for (int cel=0;cel<listeregistre.size();cel++) // on va supprimer le registre de la liste si il vient detre utilise en source
	{
		if (!stricmp(listeregistre[cel],sregs)) { 
			delete listeregistre[cel];
			listeregistre.erase(listeregistre.begin() + cel);
			break;
		}
	}


	strcpy(oldins,&type[ins][0][0]);
	
	sprintf(sins,type[ins][1],type[ins],sregd,sregs); // on crée linstruction finale
	sortie << sins;

	if (interdit)
		sortie << " //ne pas inserer de code ici" << endl;
	else
		sortie << " //pile = " << pile << endl;
	
	if (kan) kan--; //on decremente le nombre d'instruction avant de poser le label
	if (kan<=0 && interdit) { //ca y est on peut?
		sortie << label << ":" << endl;
		strcpy(label,"");
		interdit=false;
		kan=0;
	}


}

if (kan) //on a pas eu le temps de le poser?
	sortie << label << ":" << endl;


if (pile) { //on remet la pile au debut
sprintf(sins,"add esp,%d //on restaure la pile",pile);
sortie << sins <<endl;
}
sortie << "//---------- fin code factice ----------" <<endl;
for (int cel=0;cel<listeregistre.size();cel++) //on efface la liste
	delete listeregistre[cel];
listeregistre.clear();

sortie.close();
return 0;
}