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

Soyez le premier à donner votre avis sur cette source.

Vue 13 171 fois - Téléchargée 1 140 fois

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... !

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
158
Date d'inscription
samedi 31 janvier 2004
Statut
Membre
Dernière intervention
12 mars 2009

salut!
je programme generalement en C et rarement en C++ ca fait si vous verifier des annees que j'ai pas poste ni une source ni un commentaire(meme si je lis souvent des sources). j'ai lu cette source et TOUS les commentaires.
Je n'y connais rien en chiffrement/cryptage (meme en vocabulaire :)) mais faut reconnaitre que l'auteur est sur la defensive et pas pres a ecouter les critiques notemment celle de LeFauve42 qui a l'aire de s'y connaitre.
celle du debut donnaient l'impression de repondre a l'arogance de l'auteur qui au vu de ce que j'ai lu et au passage j'ai secret and lies que j'ai immediatement lu, l'auteur de notre code s'entete et s'aveugle.
Oui les commentaires sont agressif, sauf pour LeFauve42 sont assez dure a prendre quand on s'est mit soit meme tres haut. mais oui ils disent la verite. et meme moi qui m'y connait pas trop j'ai compris la difference entre ce que tu dis et ce qu'on te demande.
en un mot acceptes que tu as pas tout a fait raison sur ce coup la et ce que j'aurai fait a ta place c'est lire plus sur le sujet poster un code et demander l'avis des autres de maniere un peu plus humble et crois moi tu apprendras plus.
Messages postés
239
Date d'inscription
vendredi 20 octobre 2006
Statut
Membre
Dernière intervention
20 avril 2009

> et si on fait une attaque par header ? on peut facilement retrouver la clé, non? surtout ici avec l'exemple d'un mp3...

Oui, c'est ca dont je parlais dans mon premier post :
> Une petite remarque: si en plus tu veux crypter des fichiers (et non de l'information brute), il y a des mesures supplementaires a prendre, comme ne surtout pas crypter l'entete du fichier (celui-ci est facilement deductible, ce qui va compromettre une bonne partie de ta cle).

La procedure est :
-1) Avec une partie du message "en clair" (le header) on peut determiner une partie de la cle.
-2) Cette partie de la cle permet de decoder une partie du message.
-3) A partir de morceaux en clair du message, on peut deduire certaines parties du texte (ex: si tu as un bout de phrase comme "Cher Mons@#$$@#$#%" tu peux facilement deduire que les 4 premiers caracteres manquants sont "ieur" (suivi probablement d'une virgule ou d'un espace)).
-4) Avec cette nouvelle partie du message "clair", on peut completer un bout de la cle et revenir au "-2)" jusqu'a obtention du message complet.
Messages postés
19
Date d'inscription
samedi 7 novembre 2009
Statut
Membre
Dernière intervention
16 mai 2010

et si on fait une attaque par header ? on peut facilement retrouver la clé, non? surtout ici avec l'exemple d'un mp3...
Messages postés
4
Date d'inscription
samedi 3 septembre 2005
Statut
Membre
Dernière intervention
11 mai 2009

Si je peux me permettre, par curiosité, quel âge as-tu?
Messages postés
44
Date d'inscription
dimanche 12 mars 2006
Statut
Membre
Dernière intervention
2 mars 2013

@attreid: le chiffrement asymétrique n'est pas nouveau, il existe depuis presque 40 ans, donc ce n'est pas révolutionnaire. On se sert du chiffrement asymétrique précisément pour transférer les clés de (dé)chiffrement pour pouvoir ensuite faire du chiffrement symétrique qui est bcp plus performant.
On peut critiquer surement bcp de choses sur cette source, mais pas le choix du chiffrement symétrique :)
Afficher les 38 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.