Creer un fake code assembleur

Commenter

Contenu du snippet

Imaginer 10000 ou 100000 lignes de code sans intérêt pour nous, dans lequel on insère à droite à gauche des instructions qui s'occupent de notre protection. C'est le but de ce programme, introduire une quantité massive de code poubelle pour décourager la lecture du crackeur!!!

-pour cela il y a 2 méthodes d'insertions:
1) en réservant un registre que le générateur n'utilisera pas, et qui sera utilisé uniquement par votre code inséré
et/ou
2) en utilisant la pile, le code indique a chaque ligne le nombre de pile a rajouter pour utiliser notre vrai pile (avant notre code poubelle)

/////////////////////////////////////////////////////// example ////////////////////////////////////////

push eax // ca c'est mon vrai code

//---------- debut code factice ----------
//registre attribue: ebx
// a mettre entre _asm { }
// rajouter /Zm400 a la compilation, 400=400% de memoire en +

shl edi,7 //pile = 0
add ecx,dword ptr[esp] //pile = 0
rol edx,4 //pile = 0
or edx,dword ptr[esp] //pile = 0
shl esi,2 //pile = 0
rol eax,2 //pile = 0
neg dword ptr[esp+0] // <------ ici j'ai insere du vrai code qui touche à ma variable crée par (push eax)
shr ecx,7 //pile = 0
push 103 //pile = 4
and dword ptr[esp],ecx //pile = 4
mov ebx,dword ptr[esp+4] <----vrai code, il utilise ebx qui est reservé (en ecriture) pour notre vrai utilisation
neg dword ptr[esp] //pile = 4
inc dword ptr[esp] //pile = 4
shl esi,3 //pile = 4
add dword ptr[esp+4],4 // <---- ici j'ai insere du vrai code qui touche à ma variable crée par (push eax)
rol dword ptr[esp],3 //pile = 4
and dword ptr[esp],24728 //pile = 4
not esi //pile = 4
and edi,32005 //pile = 4
and dword ptr[esp+4],444 // <-----ici j'ai insere du vrai code qui touche à ma variable crée par (push eax)
test ecx,dword ptr[esp] //pile = 4
je L7723 //ne pas inserer de code ici
not dword ptr[esp] //ne pas inserer de code ici
xor dword ptr[esp],31541 //ne pas inserer de code ici
sub ecx,dword ptr[esp] //ne pas inserer de code ici
mul dword ptr[esp] //ne pas inserer de code ici
inc edi //ne pas inserer de code ici
add esi,ebx //ne pas inserer de code ici
and esi,10282 //ne pas inserer de code ici
or ecx,dword ptr[esp] //ne pas inserer de code ici
and esi,14454 //ne pas inserer de code ici
shr dword ptr[esp],6 //ne pas inserer de code ici
dec esi //ne pas inserer de code ici
or dword ptr[esp],7035 //ne pas inserer de code ici
dec ecx //ne pas inserer de code ici
sar dword ptr[esp],4 //ne pas inserer de code ici
sub dword ptr[esp],22751 //ne pas inserer de code ici
dec dword ptr[esp] //ne pas inserer de code ici
and dword ptr[esp],ecx //ne pas inserer de code ici
and dword ptr[esp],esi //ne pas inserer de code ici
and edi,edx //ne pas inserer de code ici
or dword ptr[esp],ecx //ne pas inserer de code ici
and dword ptr[esp],1145 //ne pas inserer de code ici
sub esi,eax //ne pas inserer de code ici
L7723:
add esp,4 //on restaure la pile
//---------- fin code factice ----------

pop eax // <----vrai code qui me permet de recuperer ma vrai variable (crée par push eax)

Source / Exemple :

#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;
}

A voir également

Creer un fake code assembleur
Créer un qcm en ligne - Forum PHP
Créer un mot caché - Forum C# / .NET
Créer un mots mélés - Forum Java
Créer un utilisateur mysql - Conseils pratiques -PHP
Créer un mot mélé - Forum Java

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.

Creer un fake code assembleur

Contenu du snippet

Source / Exemple :

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Du même auteur (syncppfrance)

Tester si le client gere les cookies dans la meme page

Interpreteur de script (1ere étape): l'evaluation d'expression