Nouvel algorithme d'encryption-désencryption dynamique (infaillible)

Télécharger le projet
Commenter

Description

Voici un nouvel algoritme d'encryption / désencryption
qui est virtuellement incassable.

Celui-ci utilise un vecteur d'initialisation de 2048 bits. Donc cassable par brute-force uniquement.

Je n'encode pas par BLOCS.... donc impossible de déterminer la clef en analysant des parties du fichier encrypté.
Je simule un masque jetable.

Donc j'ai les avantages du masque jetable sans les inconvénients d'avoir une clef aussi longue que le fichier.

Voir P.J. Document word

Source / Exemple : 


#include <windows.h>

//Fonctions Thread
DWORD WINAPI ThreadAC(LPVOID lpParam); //Thread qui s'occupe de vérifier l'état de l'interrupteur

class kaboomClass
{
private:

	DWORD ThreadID; //Thread
	HANDLE ThreadHandle;
	

	unsigned char CLEFS[256]; //Clefs sous forme d'OCTET
	bool CLEFS_B[256][8]; //Clefs sous forme de BITS
	//Clef d'encryption actuelle
	bool CLEF_ACTUELLE_B[8]; 
	unsigned char CLEF_ACTUELLE;
	unsigned char MIXKEY[8]; //indique les bits de quelle clefs à prendre (DÉPART)
	int COMPTEUR_METHODE;
	int METHODES[4]; //Indique l'ordre des méthodes a prendre (256 possibles sauf elles ne seront pas toutes prises)

public:
	bool threadOK;
	int pourcent;

	kaboomClass();
	~kaboomClass();
	void octetToBits(const unsigned char*, bool*);
	void afficherBits(bool*);
	unsigned char bitsToOctet(bool*);
	void genererClefs();
	void mixClef();
	void nextMasq();
	void afficherMasque();
	void backupKeys();
	void getKeys();
	void ENCRYPTE();
	void DECRYPTE();
	void initialiser();

}*kaboom;

kaboomClass::kaboomClass()
{
	pourcent=0;
	threadOK=true;
	//ThreadHandle=CreateThread(NULL,NULL,ThreadAC,NULL,NULL,&ThreadID);
}

kaboomClass::~kaboomClass()
{
	threadOK=false;
	TerminateThread(ThreadHandle,NULL);
}

//Extraire les 8 bits d'un octet
void kaboomClass::octetToBits(const unsigned char *octet, bool *bits) //OK FINAL
{	
	unsigned char a;
	a=octet[0];
	for (int x = 0; x <= 7; x++)
	{
		bits[x] = a & 1;
		a = a >> 1; 
	}
	return;
}

//Création d'un octet avec 8 bits
unsigned char kaboomClass::bitsToOctet(bool *bits) //OK FINAL
{	
	unsigned char byte=0;
	for (int x = 0; x <= 7; x++)
	{
		if(bits[x])
			byte+=pow((double)2,x);
	}
	return byte;
}

void kaboomClass::mixClef()
{
	for(int x=0;x<=7;x++)
	{
		CLEF_ACTUELLE_B[x]=CLEFS_B[MIXKEY[x]][x];
	}
	CLEF_ACTUELLE=bitsToOctet(CLEF_ACTUELLE_B);
}

//Simulation d'une seule méthode pour le moment
void kaboomClass::nextMasq()
{
	//Copy du masque de mélange actuel
	unsigned char temp[8];
	for(int x=0;x<=7;x++)
		temp[x]=MIXKEY[x];

	//Copy des méthodes
	int temp2[4];
	for(int x=0;x<=3;x++)
		temp2[x]=METHODES[x];

	switch(METHODES[COMPTEUR_METHODE])
	{
		case 1: //Méthode #1 = inversion totale
		{
			MIXKEY[0]=temp[4]+3;
			MIXKEY[1]=temp[5]+1;
			MIXKEY[2]=temp[0]+6;
			MIXKEY[3]=temp[3]-4;
			MIXKEY[4]=temp[1]+3;
			MIXKEY[5]=temp[2];
			MIXKEY[6]=temp[6]+2;
			MIXKEY[7]=temp[7];
			break;
		}
		case 25: //Méthode #25 : Inversion centrée
		{
			MIXKEY[0]=temp[2]-8;
			MIXKEY[1]=temp[4]+2;
			MIXKEY[2]=temp[3]+2;
			MIXKEY[3]=temp[0]+43;
			MIXKEY[4]=temp[1]-98;
			MIXKEY[5]=temp[5]+54;
			MIXKEY[6]=temp[6]+15;
			MIXKEY[7]=temp[7]-32;
			break;
		}
		case 52: //Méthode #52 : Changement de clefs
		{
			MIXKEY[0]=temp[0]+1;
			MIXKEY[1]=temp[1]-2;
			MIXKEY[2]=temp[2]-2;
			MIXKEY[3]=temp[3]+16;
			MIXKEY[4]=temp[4]+2;
			MIXKEY[5]=temp[5]-1;
			MIXKEY[6]=temp[6]+2;
			MIXKEY[7]=temp[7]-4;
			break;
		}
		case 55: //Méthode #55 : Inverser Méthodes ???
		{
			METHODES[0]=temp2[2];
			METHODES[1]=temp2[3];
			METHODES[2]=temp2[0];
			METHODES[3]=temp2[2];
			break;
		}
		default: //Méthode inconnue = inversion des paires
		{
			MIXKEY[0]=temp[5];
			MIXKEY[1]=temp[0];
			MIXKEY[2]=temp[4];
			MIXKEY[3]=temp[1];
			MIXKEY[4]=temp[2];
			MIXKEY[5]=temp[3];
			MIXKEY[6]=temp[6];
			MIXKEY[7]=temp[7];
			break;
		}
	}

	COMPTEUR_METHODE++;
	if(COMPTEUR_METHODE>3)
		COMPTEUR_METHODE=0;
}
//###################################################################

//Générer des clefs de façon aléatoire
void kaboomClass::genererClefs() //OK
{	
	srand(time(NULL));
	for(int x=0;x<=255;x++)
	{
		CLEFS[x]=rand() % 256;
		octetToBits(&CLEFS[x],CLEFS_B[x]);
	}

	for(int x=0;x<=7;x++)
		MIXKEY[x]=rand() % 256; 
	
	//****************
	METHODES[0]=1;
	METHODES[1]=25;
	METHODES[2]=52;
	METHODES[3]=55;

	backupKeys();
	return;
}

//Enregistrer les clefs
void kaboomClass::backupKeys() 
{	
	char position[15]={"kabz.kbk"};
	char *nomFichier=position;

	ofstream fichier(nomFichier,ios::ate|ios::binary); 

	//Enregistre les 256 clefs
	for(int x=0;x<=255;x++)
		fichier.write((char*)&CLEFS[x],sizeof(CLEFS[x])); 
	//Enregistre le masque
	for(int x=0;x<=7;x++)
		fichier.write((char*)&MIXKEY[x],sizeof(MIXKEY[x])); 
	//Enregistre la séquence des méthodes
	for(int x=0;x<=3;x++)
		fichier.write((char*)&METHODES[x],sizeof(METHODES[x])); 
	fichier.close();
	return;
}

//Récupérer les clefs
void kaboomClass::getKeys() 
{	
	char position[15]={"kabz.kbk"};
	char *nomFichier=position;

	ifstream fichier(nomFichier,ios::binary); 

	//OBTENIR LONGUEUR FICHIER
	fichier.seekg(0, ios::end);
	double longFich=fichier.tellg();
	fichier.seekg(0, ios::beg);

	if((longFich>0))
	{
		//Récupère les 256 clefs
		for(int x=0;x<=255;x++)
		{
			fichier.read((char*)&CLEFS[x],sizeof(CLEFS[x]));
			octetToBits(&CLEFS[x],CLEFS_B[x]); 
		}
		//Récupère le masque
		for(int x=0;x<=7;x++)
			fichier.read((char*)&MIXKEY[x],sizeof(MIXKEY[x]));
		//Récupère la séquence des méthodes
		for(int x=0;x<=3;x++)
			fichier.read((char*)&METHODES[x],sizeof(METHODES[x])); 
	}
	fichier.close();
	return;
}

//###################################################################

void kaboomClass::ENCRYPTE() 
{	
	pourcent=0;
	COMPTEUR_METHODE=0;
	genererClefs();

	char position[15]={"test.mp3"};
	char *nomFichier=position;
	ifstream fichier(nomFichier,ios::binary); 

	char position2[15]={"crypted.kbm"};
	char *nomFichier2=position2;
	ofstream fichier2(nomFichier2,ios::binary|ios::ate); 

	char position3[15]={"masque.kbm"};
	char *nomFichier3=position3;
	ofstream fichier3(nomFichier3,ios::binary|ios::ate); 

	//OBTENIR LONGUEUR FICHIER
	fichier.seekg(0, ios::end);
	double longFich=fichier.tellg();
	fichier.seekg(0, ios::beg);

	unsigned char donnee;

	if((longFich>0))
	{
		while(!fichier.eof())
		{
			mixClef();
			fichier.read((char*)&donnee,sizeof(donnee));

			donnee = donnee ^ CLEF_ACTUELLE;
			//Écriture de la donnée encryptée
			fichier2.write((char*)&donnee,sizeof(donnee));
			//Écriture du masque jetable
			fichier3.write((char*)&CLEF_ACTUELLE,sizeof(CLEF_ACTUELLE));

			//pourcent = fichier.tellg() / longFich * 100;

			nextMasq();
		}
	}
	fichier.close();
	fichier2.close();
	fichier3.close();
	return;
}

void kaboomClass::DECRYPTE() 
{	
	pourcent=0;
	COMPTEUR_METHODE=0;
	getKeys();

	char position[15]={"crypted.kbm"};
	char *nomFichier=position;
	ifstream fichier(nomFichier,ios::binary); 

	char position2[15]={"decrypted.mp3"};
	char *nomFichier2=position2;
	ofstream fichier2(nomFichier2,ios::binary|ios::ate); 

	//OBTENIR LONGUEUR FICHIER
	fichier.seekg(0, ios::end);
	double longFich=fichier.tellg();
	fichier.seekg(0, ios::beg);

	unsigned char donnee;

	if((longFich>0))
	{
		while(!fichier.eof())
		{
			mixClef();
			fichier.read((char*)&donnee,sizeof(donnee));

			donnee = donnee ^ CLEF_ACTUELLE;

			fichier2.write((char*)&donnee,sizeof(donnee));

			//pourcent = fichier.tellg() / longFich * 100;

			nextMasq();
		}
	}
	fichier.close();
	fichier2.close();
	return;
}

DWORD WINAPI ThreadAC(LPVOID lpParam)
{
	while(kaboom->threadOK) //Serveur tout le temps en fonction (à date)
	{
		system("cls"); 
	    cout << kaboom->pourcent << "%";
		Sleep(100);
	}
	return 0;
}

Conclusion :


Veuillez lire le tutoriel .DOC que j'ai inclu dans le ZIP.

Sérieusement, je ne sais pas si j'ai inventé de quoi ou bien je suis dans les patates.

En tout cas; je SAIS QUE CELA FONCTIONNE #1.

J'Ai encrypté un fichier de 1 meg avec seulement des "00" dedant et le fichier crypté est méconnaissable !!

Bonne découverte... !
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.