Creer un fake code assembleur

Soyez le premier à donner votre avis sur cette source.

Snippet vu 7 186 fois - Téléchargée 33 fois

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

Ajouter un commentaire Commentaires
Messages postés
123
Date d'inscription
samedi 29 novembre 2003
Statut
Membre
Dernière intervention
11 mars 2007

Bien vu je trouve :)

C'est vrai qu'en C/C++ si on insère du code bidon il ne sera même pas pris en compte...
Juste une chose, ça allourdi le programme ça ... C'est son seul défaut :)
Ca devrait décourager qques petits crackeurs en herbe :)
Messages postés
33
Date d'inscription
lundi 12 avril 2004
Statut
Membre
Dernière intervention
16 décembre 2004

lol,,cyberboy!!!!!!!!!!! oué c moi!!!!!!!!! ca va ?
non,, Zm400 sert juste à la compilation
Messages postés
173
Date d'inscription
jeudi 20 décembre 2001
Statut
Membre
Dernière intervention
22 août 2008

Lut
Je suis pas sur d'avoir compris comment marche la chose (peut etre parce que je n'y connais pas grand chose en asm), mais l'idée me semble intéressante.
Par contre, est ce que zm400 signifie que le programme consomme 4* plus de mémoire ? si oui, ca me semble un gros frein pour pas mal de choses ...
(Sinon, c'est toi le synack qui trainait sur glinfrench ?)
Messages postés
33
Date d'inscription
lundi 12 avril 2004
Statut
Membre
Dernière intervention
16 décembre 2004

en tous cas je ne devrai plus mettre a jour ke code, car jai fait 100000 lignes de codes generé et jai reussis a les compiler sans probleme.

en general, une protection si on veut essayer de bloquer le crackeur, c'est d'ecrire en assembleur.
je parle pas d'un simple test serial==serialentree. ca vaut que dalle ca!!!!

de plus:
1) essai de taper du code en c++/c pour faire du bidon comme une serie de :
int g=4;
int f=2;
g++;
f=g+55+f;
...
// ce genre de code, n'est meme pas compiler, car ce n'est pas utiliser par le reste du programme, il est simplement mis en commentaire par le compilateur

2) si tu copies 50 programmes en un seul, va falloir que tu penses a copier toutes les variables, .... sinon tu vas bien te faire chier à la compil. en plus, kan tu vas executer ces 50 programmes reel copier a la suite les un des autres, ca va faire des choses que tu nauras pas forcement envie, donc tu vas t'amuser a modifier,... et perdre des heures pour rien.


pour ta question mystere, un crackeur, n'est qu'une personne comme nous autres, quand tu as 100000 vrai lignes ( c pas a la marseillaise lol!!!) a regarder qui se ressemble, pour quelques instructions veritable qui se court apres, crois moi que si dans ta personnalité tu n'est pas tenace,, tas vite fait de lacher, ou meme de te melanger les pinceaux. Ce qui deja eliminera certains crackeurs.
Messages postés
4525
Date d'inscription
dimanche 29 septembre 2002
Statut
Modérateur
Dernière intervention
22 avril 2019
9
Je comprend pas trop l'utilité de la chose tu peut tout aussi bien inserer des vrais fausses lignes de code en C ou bien mettre 50 programmes un seul ça ne fera que polluer ton code...

De plus je te pose la question mistere as tu deja vue un crackeur ce decourager ?
Afficher les 6 commentaires

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.