Forum Ubuntu-fr.org / [C++] Sondage: programmes de chiffrement amateur. [Resolu]

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (Destroyers) — Mon, 21 Jan 2013 10:52:39 +0000

non mais le programme du forum n'est pas a jour

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (tiramiseb) — Mon, 21 Jan 2013 10:43:28 +0000

Et t'as testé avec "titi" ?

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (Destroyers) — Mon, 21 Jan 2013 10:42:01 +0000

T'inquiète pas, j'ai réglé le problème toto dès que j'ai su que ça ne marchait pas x)

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (Stalker2106) — Mon, 21 Jan 2013 10:27:51 +0000

Dans le cas de destroyers il serait en effet interessant qu'il regarde du coté de ces bobliothèques tierces, c'est toujours bon d'avoir des conaissances sous la main.
En revanche, j'ai pris pas mal de retard avec ce défi si bien que je n'ai pas meme encore commencé l'apprentissage avancé de la POO.
En bref j'en conclut qu'en dépit du fonctionnement de CRYPTconsol, Encryptor l'emporte sur sa meilleure lisibilité des menus.

Merci de vos réponses et de vos partages de bibliothèques, il sera interessant pour moi de les etudier par la suite !
Cordialement

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (tiramiseb) — Mon, 21 Jan 2013 10:19:52 +0000

Les differents cryptages sont evidemment simpliste le but n'etant pas de concurrencer certains algo biens connus, mais surtout de mettre en pratique les bases du C++ en employant de la gestion de fichier en ecriture, lecture, de la gestion I/O avec du cout cin, getline ou encore des test de securité ( avec des conditions "si le fichier est deja codé alors" ) qui impliquent une gestion des differentes issues du programme.

Dans ce cas c'est un bon exercice, et je vous invite à vous pencher sur les bibliothèques existantes pour l'interface (histoire de mettre en pratique l'utilisation de bibliothèques tierces par exemple) !

Par contre du coup je ne suis pas assez compétent en développement C++ pour donner un avis pertinent sur telle ou telle méthode de gestion des I/O etc.

Mais je suis capable de dire que CRYPTconsol ne sait pas gérer la chaîne "toto" sans afficher une erreur, il y a donc des améliorations à faire au niveau de la gestion des erreurs

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (tiramiseb) — Mon, 21 Jan 2013 10:17:20 +0000

Oui désolé, je suis du genre à pas prendre de pincettes (la diplomatie est hors de mon champ de compétences)...

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (Stalker2106) — Mon, 21 Jan 2013 10:16:34 +0000

D'abord, merci d'avoir consacré du temps à vous pencher sur nos programme, d'autre part, il est evident qu'aucun de nous deux n'a la prétention d'affirmer que ce logiciel sera utilisé par les internautes: je le dis et je le répetes, il n'est pas ici question de faire quelque chose de propre et de soigné ( bien que cela aurait été préfèrable je vous l'accorde. )
Les differents cryptages sont evidemment simpliste le but n'etant pas de concurrencer certains algo biens connus, mais surtout de mettre en pratique les bases du C++ en employant de la gestion de fichier en ecriture, lecture, de la gestion I/O avec du cout cin, getline ou encore des test de securité ( avec des conditions "si le fichier est deja codé alors" ) qui impliquent une gestion des differentes issues du programme.

Je prends vos remarques de maniere constructive et j'attends avec impatience la suite !
Cordialement

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (sogyam) — Mon, 21 Jan 2013 10:15:48 +0000

Non vous êtes pas nuls, c'est juste que les conseils sont des fois dit d'une manière directe, ne le prenez pas mal !!

c'est vrai que par exemple une archive avec le code et l'executable c'est pas dur à faire ... et tu la met en téléchargement !!
voili voilà

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (tiramiseb) — Mon, 21 Jan 2013 10:09:50 +0000

Si la question est "nos méthodes de chiffrement sont-elles bonnes ?", alors la réponse est clairement "elles sont nulles".

S'il s'agit de s'entraîner à programmer, bah ça vous ferait un bon exercice d'améliorer vos codes

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (Destroyers) — Mon, 21 Jan 2013 10:07:24 +0000

Bref: on est nul

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (tiramiseb) — Mon, 21 Jan 2013 09:55:34 +0000

Tu aurais pu donner les sources sous forme d'archives, c'est pénible de lire comme ça sur le forum...

-----------------

Houla mais vos chiffrements sont super simplistes ! En terme de sécurité, c'est nullissime.
C'est presque plus du codage que du chiffrement...
On n'est pas loin du ROT13...

Je vous laisse jeter un oeil par là :
http://fr.wikipedia.org/wiki/Chiffrement
http://fr.wikipedia.org/wiki/Data_Encryption_Standard
http://fr.wikipedia.org/wiki/Triple_DES
http://fr.wikipedia.org/wiki/Standard_d … vanc%C3%A9

Par ailleurs je n'arrive pas à comprendre pourquoi vos codes parlent de hashage.
Vous savez ce que c'est, le hashage ?
http://fr.wikipedia.org/wiki/Fonction_de_hachage

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (Destroyers) — Mon, 21 Jan 2013 09:47:12 +0000

On voulais surtout avoir des avis d'utilisateurs ^^'
mais puisqu'on y est, voici les code:
(ne faites pas de remarques sur la méthode que nous avons employés pour remplacer les caractères, ce sont des switch: peu performants, mais a notre niveau)

Sources de CRYPTconsol:

/*
CHOSES A FAIRE:

-ajouter une langue (anglais).
-ajouter une option pour chiffrer directement les fichiers.
*/

//main.cpp

#include"header.h"


char langue;


int main()
{

	 std::cout<<"\n\nBienvenue dans votre logiciel de cryptage 'CRYPTconsol' (Beta 2.0).\n";
	 std::cin.ignore(std::numeric_limits::max(),'\n');

	 bool entree_valide (false);  //savoir si l'entrée est valide
	 bool i(true);   //le programme s'arrete si i==false
	 code txt;   //on instancie un texte de type code.
	 short int choix;  //le choix de l'action de l'utilisateur

       	 while (i)
       	 {
            	do
            	{
                	std::string s;
                	std::cout<<"\n\n";
                	std::cout<<"Tapez 1 pour manipuler votre texte,";
			if(txt.get_ecrit()) //indique si un texte est présent, crypté ou non, et indique la taille du texte
			{
				if(txt.get_crypte())
				{
					std::cout<<" (un texte est actuellement présent (" <> choix);
    			
                    if(!entree_valide)
                    {
                        std::cout << "Erreur: choix inexistant.\n";
    					std::cin.ignore(std::numeric_limits::max(),'\n');
                    }

            } while(!entree_valide);

            switch(choix)
            {
                case 1:
                	menu_texte(txt);
                	break;

                case 2:
                	txt.afficher_message();
                	break;

                case 3:
                	txt.exporter();
                	break;

                case 4:
                	menu_importer(txt);
                	break;

                case 5:
                	affiche_historique();
                	break;

                case 6:
                	i=false;
                	break;

                default:
                	std::cout<<"Erreur, choix inexistant.\n";
                break;
            }
    	}

    return 0;
}

//action.h

#ifndef action
#define action

#include"header.h"


class code
{
	protected:
	std::string phrase; //contient le texte
	int taille;  //contient le nombre de caractères du texte
	bool ecrit; //savoir si "phrase" est vide (false) ou si il contient un texte (true)
	bool crypte;//savoir si "phrase" est chiffré(true) ou non(false)

	public:
	code();

	void verifier_ecrire();//verifie si un texte est présent
	void ecrire();
	void afficher_message()const;
	void supprimer();
	void coder_decoder();//vérifie si le texte doit etre chiffré  ou déchiffré
	void coder();
	void decoder();
	void exporter() const;
	void importer();//importe un fichié crypté
	void importer_exterieur();//importe un fichier non crypté

	bool get_ecrit() const;
	bool get_crypte() const;
	int get_taille() const;

};

void affiche_historique();
void menu_texte(code& txt);
void menu_importer(code& txt);

#endif

//action.cpp

#include"action.h"


code::code() : taille(0), ecrit(false), crypte(false) 
{
}


void code::verifier_ecrire()
//verifie si un texte est déjà présent ou non
{	
	if(ecrit)
	{
		bool entree_valide;
		short int choix;
		do
		{
			std::cout<<"Attention, un texte est déjà présent:\n";
			std::cout<<"tapez 1 pour continuer,\n";
			std::cout<<"tapez 2 pour annuler.\n";		
			std::string s;
			std::getline(std::cin,s);
        		std::istringstream iss(s);  //cette partie permet de ne pas planter le programme si
                                        	// on entre des lettres (car "choix" est de type int)
        		entree_valide = (iss >> choix);
			if(!entree_valide||(choix!=1 && choix!=2))
			{
				std::cout<<"Erreur: choix inexistant.\n";
			}

		}while(!entree_valide||(choix!=1 && choix!=2));

		if(choix==1)
		{
			ecrire();
		}
		else
		{
			std::cout<<"Texte intacte.\n";
  		    	std::cin.ignore(std::numeric_limits::max(), '\n');
		}
	}
	else
	{
		ecrire();
	}
}


void code::ecrire()
//écrire un texte
{
	std::cout<<"Entrez votre texte: \n";
    	std::cin.ignore(std::numeric_limits::max(), '\n');   //si on enlève cette ligne, ça marche pas...
    	std::getline(std::cin, phrase);
    
    	if(phrase.size()==0)
    	{
        	std::cout<<"Erreur: une erreur est survenue lors de l'entrée de votre texte.\n";
		std::cin.ignore(std::numeric_limits::max(), '\n');

	}
	else
	{
	    	std::cout<<"Votre texte est prêt.\n";
		ecrit=true;
		taille=phrase.size()-1;
	    	std::cin.ignore(std::numeric_limits::max(), '\n');
	}
}


void code::afficher_message() const
//affiche le texte en cours
{
    std::cout<<"Vous voulez afficher votre texte: ... \n";
    if(ecrit==true)
    {
        	std::cout<::max(), '\n');
		std::cin.ignore(std::numeric_limits::max(), '\n');
    }
    else if(ecrit==false)
    {
        	std::cout<<"Erreur: aucun texte n'est présent.\n";
		std::cin.ignore(std::numeric_limits::max(), '\n');
		std::cin.ignore(std::numeric_limits::max(), '\n');
    }

}


void code::supprimer()
//supprime le texte en cours
{
	bool entree_valide;
	do{
		std::cout<<"voulez vous vraiment supprimer votre texte ?\n (tapez oui, non, o, n)\n";	
		std::string choix;
		std::getline(std::cin,choix);
		for(unsigned int i=0;i::max(), '\n');
				std::cin.ignore(std::numeric_limits::max(), '\n');
   	  	    	}
   	 	    	else if(ecrit==false)
   	 	    	{
        			std::cout<<"Erreur: aucun texte n'est présent.\n";
				std::cin.ignore(std::numeric_limits::max(), '\n');
				std::cin.ignore(std::numeric_limits::max(), '\n');
       			}
		}	
   		else if(choix=="non"||choix=="no"||choix=="n")
		{
			entree_valide=true;
			std::cout<<"Votre texte est intacte.\n";
			std::cin.ignore(std::numeric_limits::max(), '\n');
			std::cin.ignore(std::numeric_limits::max(), '\n');
		}
		else
		{
			std::cout<<"Erreur: choix inexistant.\n";
			std::cin.ignore(std::numeric_limits::max(), '\n');
			std::cin.ignore(std::numeric_limits::max(), '\n');
			entree_valide=false;
		}

	}while(!entree_valide);
}


void code::coder_decoder()
//vérifie si le texte est chiffré ou non
{
	if(crypte)
	{
		decoder();
	}
	else
	{
		coder();
	}
}


void code::coder()
//chiffre le texte
{
    	std::cout<<"Vous voulez crypter votre texte: ... \n";
    	if(ecrit==true && crypte==false)
    	{
		srand(time(0));
        	short int choix(rand()%4);  //on détermine aléatoirement le type d'encodage

        	switch(choix)
        	{
			case 0:
			    	choix0(phrase);
			   	crypte=true;
			    	std::cout<<"Votre texte a bien été chiffré.\n";
			   	std::cin.ignore(std::numeric_limits::max(), '\n');
			   	std::cin.ignore(std::numeric_limits::max(), '\n');
			   	break;

			case 1:
			    	choix1(phrase);
			    	crypte=true;
			    	std::cout<<"Votre texte a bien été chiffré.\n";
			   	std::cin.ignore(std::numeric_limits::max(), '\n');
			    	std::cin.ignore(std::numeric_limits::max(), '\n');
			    	break;

			case 2:
			    	choix2(phrase);
			    	crypte=true;
			    	std::cout<<"Votre texte a bien été chiffré.\n";
			   	std::cin.ignore(std::numeric_limits::max(), '\n');
			    	std::cin.ignore(std::numeric_limits::max(), '\n');
			    	break;

			case 3:
			    	choix3(phrase);
			    	crypte=true;
			    	std::cout<<"Votre texte a bien été chiffré.\n";
			   	std::cin.ignore(std::numeric_limits::max(), '\n');
			    	std::cin.ignore(std::numeric_limits::max(), '\n');
			    	break;

			case 4:
			    	choix4(phrase);
			    	crypte=true;
			    	std::cout<<"Votre texte a bien été chiffré.\n";
			   	std::cin.ignore(std::numeric_limits::max(), '\n');
			    	std::cin.ignore(std::numeric_limits::max(), '\n');
			    	break;
		}
		phrase+='*'; //on ajoute une étoile comme signature de CRYPTconsol

		short int premier(rand()%5);  //on ajoute un caractère au début et à la fin aléatoirement, sans aucune signification (sécurité)
		if(premier==0)
		{
			std::string temporaire;
			temporaire+='$';
			for(unsigned int i=0;i::max(), '\n');
		std::cin.ignore(std::numeric_limits::max(), '\n');
	}
    	else if(ecrit==false)
    	{
        	std::cout<<"Erreur: aucun texte n'est présent.\n";
		std::cin.ignore(std::numeric_limits::max(), '\n');
    		std::cin.ignore(std::numeric_limits::max(), '\n');
    	}
   	else
    	{
        	std::cout<<"Erreur: une erreur inconue est survenue.\n";
		std::cin.ignore(std::numeric_limits::max(), '\n');
    		std::cin.ignore(std::numeric_limits::max(), '\n');
    	}

}


void code::decoder()
//déchiffre le texte
{
    std::cout<<"Vous voulez déchiffrer votre texte: ... \n";
    if(crypte==true)
    {
		char premier=phrase[0]; //on supprime le premier et le dernier caractère potentiellements présents qui n'ont aucune signification (sécurité)
		if(premier=='$'||premier=='Q'||premier=='%')
		{
			if(premier=='$'||premier=='Q')
			{
				phrase.erase(phrase.size()-1,1);
			}
			phrase.erase(0,1);
		}

        	decode(phrase);
		phrase.erase(0,1); //on efface le type d'encodage
		phrase.erase(phrase.size()-1,1); //on efface l'étoile

        std::cout<<"Votre texte a bien été déchiffré.\n";
	std::cout<<"Voici le contenu:\n\n"<::max(), '\n');
	std::cin.ignore(std::numeric_limits::max(), '\n');
        crypte=false;
	taille=phrase.size();
    }
    else if(crypte==false && ecrit==true)
    {
        std::cout<<"Erreur: vous ne pouvez pas déchiffrer un texte non crypté.\n";
		std::cin.ignore(std::numeric_limits::max(), '\n');
		std::cin.ignore(std::numeric_limits::max(), '\n');
    }
    else if(ecrit==false)
    {
        std::cout<<"Erreur: aucun texte n'est présent.\n";
		std::cin.ignore(std::numeric_limits::max(), '\n');
		std::cin.ignore(std::numeric_limits::max(), '\n');
    }
    else
    {
        std::cout<<"Erreur: une erreur inconue est survenue.\n";
		std::cin.ignore(std::numeric_limits::max(), '\n');
		std::cin.ignore(std::numeric_limits::max(), '\n');
    }

}


 void code::exporter() const
 //enregistrer le texte dans un fichier
{
	    std::cout<<"Vous voulez enregistrer votre texte dans un fichier: ... \n";
	    if(ecrit)
	    {
			std::string fichier;
			std::cout<<"Entrez le chemin où votre fichier sera enregitré. \n";
			std::cout<<"Terminez par le nom de votre fichier puis l'extention texte de votre choix. \n";
			std::cout<<"(tapez 1 pour annuler). \n";
			std::getline(std::cin,fichier);
			std::ofstream flux (fichier.c_str()); //on ouvre un fichier là ou l'utilisateur le veux
			if(fichier=="1")
			{
				std::cout<<"Vous avez annulé l'enregistrement.\n";
			}
			else if(flux)
			{
				flux<::max(), '\n');
				std::cin.ignore(std::numeric_limits::max(), '\n');
			}
			else
			{
			    	std::cout<<"Erreur: une erreur est survenue lors de la création du fichier.\n";
			    	std::cout<<"avez vous correctement entré le chemin ?\n";
			    	std::cin.ignore(std::numeric_limits::max(), '\n');
				std::cin.ignore(std::numeric_limits::max(), '\n');
			}
	    }
	    else if (!ecrit)
	    {
		std::cout<<"Erreur: aucun texte n'est écrit.\n";
			std::cin.ignore(std::numeric_limits::max(), '\n');
			std::cin.ignore(std::numeric_limits::max(), '\n');
	    }
	    else
	    {
		std::cout<<"Erreur: une erreur inconue vient de se produire.\n";
			std::cin.ignore(std::numeric_limits::max(), '\n');
			std::cin.ignore(std::numeric_limits::max(), '\n');
	    }
}


void code::importer()
//importer le texte crypté par CRYPTconsol depuis un fichier
{
	std::cout<<"Vous voulez importer un texte crypté par CRYPTconsol depuis un fichier: \n";
	std::string chemin;
	std::cout<<"Entrez le chemin où se trouve votre fichier.\n";
	std::cout<<"terminez par le nom de votre fichier avec l'extention (les majuscules doivent être respectées).\n";
	std::cout<<"(tapez 1 pour annuler). \n";
	std::getline(std::cin,chemin);

    	std::ifstream flux (chemin.c_str());

	if(chemin=="1")
	{
		std::cout<<"Vous avez annulé l'importation.\n";
	}

        else if(flux)
    	{
		int size; //contient la taille du fichier SANS les caractères ajoutés (* par exemple) donc la taille réele
	    	bool etoile; //savoir si l'étoile est présente
		char dernier;//savoir quel est le dernier caractère (p ou *)
	    	char premier;//savoir quel est le premier caractère
		char deuxieme;//savoir quel est le deuxieme charactère (selon le premier)
		bool dernier_p;//savoir si le dernier caractère est un "p"
		int test; //contient la taille du fichier AVEC les caractères ajoutés (* par exemple) pour tout prendre du fhichier (voir la boucle for)

		flux.seekg(0,std::ios::end);
		size=flux.tellg();   // on enregistre la taille du fichier
		test=size;
		flux.seekg(0, std::ios::beg);
		flux.get(premier);   //on vérifie que le type d'encodage est présent
		flux.seekg(1, std::ios::beg);
		flux.get(deuxieme);
		flux.seekg(-1,std::ios::end);
		flux.get(dernier);   // on verifie si le dernier caractère est une étoile
	   	if(dernier=='*')
		{
	  		etoile=true;  //verifie si le dernier caractere est une étoile
			dernier_p=false;
			if(premier=='%')
			{
				size-=3;
			}
			else
			{
				size-=2;
			}
   		}
		else if(dernier=='p') //vérifie si l'étoile est présente si le dernier caractère est un "p"	
		{
			size-=4;			
			flux.seekg(-2,std::ios::end);
			flux.get(dernier);
			dernier_p=true;
			if(dernier=='*')
			{
	  			etoile=true;
			}
			else
			{
				etoile=false;
			}
		}
		else
		{
			etoile=false;
			dernier_p=false;
		}

        if(size==0)
        {
			std::cout<<"Erreur: le fichier que vous avez indiqué est vide.\n";
			std::cin.ignore(std::numeric_limits::max(), '\n');
			std::cin.ignore(std::numeric_limits::max(), '\n');
        }
        else if(size!=0)
        {
		if(etoile==true && (((premier=='0'||premier=='M'||premier=='1' || premier=='L'||premier=='2'||premier=='j'||premier=='3'||premier=='!'||premier=='4'||premier=='b'||premier=='%') &&(dernier_p==false))||(dernier_p==true && (premier=='$' || premier=='Q')&&(deuxieme=='0' || deuxieme=='M' ||deuxieme=='1' || deuxieme=='L' || deuxieme=='2' || deuxieme=='j'||premier=='3'||premier=='!'||premier=='4'||premier=='b'))||(premier=='%' && dernier_p==false &&(deuxieme=='0' || deuxieme=='M' ||deuxieme=='1' || deuxieme=='L' || deuxieme=='2' || deuxieme=='j'||premier=='3'||premier=='!'||premier=='4'||premier=='b'))))
        	{
		flux.seekg(0, std::ios::beg);
		std::string texte;	   
            	for(int i(0); i::max(), '\n');
		std::cin.ignore(std::numeric_limits::max(), '\n');
            	}           
		else if(etoile==false||(premier!='0' && premier!='M' && premier!='1'&& premier!='L' && premier!='2'&& premier!='j'&& premier!='3'&& premier!='!' && premier!='4'&& premier!='b' && premier!='$' && premier!='Q'&& premier!='%')||(dernier_p==true && premier!='$' && premier!='Q'&& premier=='%')||((premier=='$'|| premier=='Q'||premier=='%')&&(deuxieme!='0'&& premier!='M'&& deuxieme!='1' && premier!='L' && deuxieme!='2'&& premier!='j'&& premier!='3'&& premier!='!' && premier!='4'&& premier!='b')))
            {
                std::cout<<"Erreur:"<<'\n'
                <<"-soit le texte contenu dans votre fichier n'est pas codé\n"
                <<"-soit votre fichier crypté n'est pas originaire de CRYPTconsol\n"
                <<"-soit votre fichier a été modifié.\n";

		std::cin.ignore(std::numeric_limits::max(), '\n');
		std::cin.ignore(std::numeric_limits::max(), '\n');
            }
            else
            {
                std::cout<<"Erreur: une erreur inconnue est survenue lors du transfert des donées.\n";
				std::cin.ignore(std::numeric_limits::max(), '\n');
				std::cin.ignore(std::numeric_limits::max(), '\n');

            }
        }
        else
        {
			std::cout<<"Erreur: une erreur inconnue vient de se produire.\n";
			std::cin.ignore(std::numeric_limits::max(), '\n');
			std::cin.ignore(std::numeric_limits::max(), '\n');
        }
    }
    else
    {
        std::cout<<"Erreur: il y a eu une erreur lors de l'ouverture du fichier.\n";
		std::cout<<"l'extention de votre fichier, est-elle correcte ? (.txt .odt .doc ...)\n";
        std::cout<<"avez vous correctement entré le chemin ?\n";
		std::cin.ignore(std::numeric_limits::max(), '\n');
		std::cin.ignore(std::numeric_limits::max(), '\n');

    }

}


void code::importer_exterieur()
//importer un texte non crypté
{
	std::cout<<"Vous voulez importer un texte non crypté depuis un fichier: \n";
    	std::string chemin;
    	std::cout<<"Entrez le chemin où se trouve votre fichier.\n";
    	std::cout<<"terminez par le nom de votre fichier avec l'extention (les majuscules doivent être respectées).\n";
        std::cout<<"(tapez 1 pour annuler). \n";
    	std::getline(std::cin,chemin);


    	std::ifstream flux (chemin.c_str());

	if(chemin=="1")
	{
		std::cout<<"Vous avez annulé l'importation.\n";
	}

        else if(flux)
    	{
	 	int size; //nombre de caractères du fichier
	    	bool etoile; //vérifie si le fichier est crypté(ce qui ne serait pas normal)
		char dernier;
	    	char premier;
		char deuxieme;
		bool dernier_p;

		flux.seekg(0,std::ios::end);
		size=flux.tellg();   // on enregistre la taille du fichier
		flux.seekg(0, std::ios::beg);
		flux.get(premier);   //on vérifie que le type d'encodage est présent
		flux.seekg(1, std::ios::beg);
		flux.get(deuxieme);
		flux.seekg(-1,std::ios::end);
		flux.get(dernier);   // on verifie si le dernier caractère est une étoile

	   	if(dernier=='*')
		{
	  		etoile=true;       //on vérifie si le texte n'est pas déjà crypté
			dernier_p=false;
   		}
		else if(dernier=='p')
		{
			flux.seekg(-2,std::ios::end);
			flux.get(dernier);
			dernier_p=true;
			if(dernier=='*')
			{
	  			etoile=true;
			}
			else
			{
				etoile=false;
			}
		}
		else
		{
			etoile=false;
			dernier_p=false;
		}

	    if(size==0)
	    {
			std::cout<<"Erreur: le fichier que vous avez indiqué est vide.\n";
			std::cin.ignore(std::numeric_limits::max(), '\n');
			std::cin.ignore(std::numeric_limits::max(), '\n');
	    }
	    else if(size!=0)
	    {
		if(etoile==true && (((premier=='0'||premier=='M'||premier=='1' || premier=='L'||premier=='2'||premier=='j'||premier=='3'||premier=='!'||premier=='4'||premier=='b'||premier=='%') &&(dernier_p==false))||(dernier_p==true && (premier=='$' || premier=='Q')&&(deuxieme=='0' || deuxieme=='M' ||deuxieme=='1' || deuxieme=='L' || deuxieme=='2' || deuxieme=='j'||premier=='3'||premier=='!'||premier=='4'||premier=='b'))||(premier=='%' && dernier_p==false &&(deuxieme=='0' || deuxieme=='M' ||deuxieme=='1' || deuxieme=='L' || deuxieme=='2' || deuxieme=='j'||premier=='3'||premier=='!'||premier=='4'||premier=='b'))))
           	{
			std::cout<<"Erreur: le texte contenu est déjà crypté par CRYPTconsol.\n";
           	}                        
           	else
           	{
            		flux.seekg(0, std::ios::beg);
			std::string texte;	  
		     	for(int i(0); i::max(), '\n');
			std::cin.ignore(std::numeric_limits::max(), '\n');
	    	}
        }
        else
        {
			std::cout<<"Erreur: une erreur inconnue vient de se produire.\n";
			std::cin.ignore(std::numeric_limits::max(), '\n');
			std::cin.ignore(std::numeric_limits::max(), '\n');
        }
	}
	else
    {
    	std::cout<<"Erreur: il y a eu une erreur lors de l'ouverture du fichier.\n";
	std::cout<<"l'extention de votre fichier, est-elle correcte ? (.txt .odt .doc ...)\n";
        std::cout<<"avez vous correctement entré le chemin ?\n";
	std::cin.ignore(std::numeric_limits::max(), '\n');
	std::cin.ignore(std::numeric_limits::max(), '\n');

    }
}


bool code::get_ecrit() const
{

	return ecrit;
}


bool code::get_crypte() const
{

	return crypte;
}


int code::get_taille() const
{

	return taille;
}



void affiche_historique()
{
	std::cout<<"\n\n\nHistorique de développement:\n\n\n";

	std::cout<<"alpha 1.0:\n\n";
	std::cout<<"-ajout de la fonctionnalié 'écrire'\n";
	std::cout<<"-ajout de la fonctionnalié 'afficher'\n";
	std::cout<<"-ajout de la fonctionnalié 'chiffrer'\n";
	std::cout<<"-ajout de la fonctionnalié 'enregistrer'\n";

	std::cout<<"\n\nalpha 1.2:\n\n";
	std::cout<<"-ajout de la fonctionnalié 'déchiffrer'\n";
	std::cout<<"-augmentation du nombre de type d'encodage\n";

	std::cout<<"\n\nbeta 1.0:\n\n";
	std::cout<<"-ajout de la fonctionnalié 'supprimer'\n";
	std::cout<<"-ajout de la fonctionnalié 'importer un texte chiffré'\n";
	std::cout<<"-ergonimie améliorée\n";

	std::cout<<"\n\nbeta 1.2:\n\n";
	std::cout<<"-ajout de la fonctionnalié 'importer un texte non chiffré'\n";
	std::cout<<"-performances processeur améliorées\n";
	std::cout<<"-sécurité du chiffrement améliorée\n";
	std::cout<<"-augmentation du nombre de type d'encodage\n";
	std::cout<<"-ajout d'un historique de développement\n";

	std::cout<<"\n\nbeta 1.3:\n\n";
	std::cout<<"-correction de divers bugs\n";
	std::cout<<"-performances mémoire améliorées\n";
	std::cout<<"-sécurité du chiffrement améliorée\n";
	std::cout<<"-ergonimie améliorée\n";

	std::cout<<"\n\nbeta 1.8:\n\n";
	std::cout<<"-gestion des majuscules\n";
	std::cout<<"-gestion de divers nouveaux caractères\n";
	std::cout<<"-les caractères non gérés sont simplement ignorés\n";
	std::cout<<"-augmentation du nombre de type d'encodage\n";

	std::cout<<"\n\nbeta 2.0:\n\n";
	std::cout<<"-augmentation des performances\n";
	std::cout<<"-correction de divers bugs\n";

	std::cout<<"\nRemontez pour voir les mises à jour plus anciennes.\n";


	std::cin.ignore(std::numeric_limits::max(), '\n');
	std::cin.ignore(std::numeric_limits::max(), '\n');
}


void menu_texte(code& txt)
{
	bool entree_valide=false;
	short int choix;
    	bool i(true);   //la boucle s'arrete si i==false
	std::cout<<"Vous voulez manipuler votre texte:\n\n";
	
	while(i)
	{
		do
		{
			std::cout<<"\n\n\n";
			std::cout<<"tapez 1 pour écrire un nouveau texte,";
			if(txt.get_ecrit())
				{
				if(txt.get_crypte()) //indique si un texte est présent, crypté ou non, et indique la taille du texte
				{
					std::cout<<" (un texte est actuellement présent (" <> choix);    			
			if(!entree_valide)
			{
				std::cout << "Erreur: choix inexistant.\n";
		    		std::cin.ignore(std::numeric_limits::max(),'\n');
			}

		}while(!entree_valide);

		switch(choix)
		{
		        case 1:
		        	txt.verifier_ecrire();
				i=false;
		        	break;

			case 2:
				txt.supprimer();
				i=false;
				break;

			case 3:
				txt.coder_decoder();
				i=false;
				break;

			case 4:
				i=false;
				break;

			default:
				std::cout<<"Erreur, choix inexistant.\n";
				break;
		}
	}
}


void menu_importer(code& txt)
{
	bool entree_valide=false;
	short int choix;
    	bool i(true);   //la boucle s'arrete si i==false
	std::cout<<"Vous voulez importer un texte depuis un fichier:\n\n";

	while(i)
	{
		do
		{
			std::cout<<"\n\n\n";
			std::cout<<"tapez 1 pour importer un texte déjà chiffré par CRYPTconsol,\n";
			std::cout<<"tapez 2 pour importer un texte non chiffré,\n";
			std::cout<<"tapez 3 pour retourner au menu précédent.\n";

			std::string s;
			std::getline(std::cin,s);
			std::istringstream iss(s);  //cette partie permet de ne pas planter le programme si
				                            // on entre des lettres (car "choix" est de type int)
			entree_valide = (iss >> choix);    			
			if(!entree_valide)
			{
				std::cout << "Erreur: choix inexistant.\n";
		    		std::cin.ignore(std::numeric_limits::max(),'\n');
			}

		}while(!entree_valide);

		switch(choix)
		{
		        case 1:
		        	txt.importer();
				i=false;
		        	break;

			case 2:
				txt.importer_exterieur();
				i=false;
				break;

			case 3:
				i=false;
				break;

			default:
				std::cout<<"Erreur, choix inexistant.\n";
				break;
		}
	}
}

//codage.h

#ifndef codage
#define codage

#include"header.h"

void choix0(std::string& a); //les diverses fonctions de chiffrement selon l'encodage
void choix1(std::string& a);
void choix2(std::string& a);
void choix3(std::string& a);
void choix4(std::string& a);

void decode(std::string& a); //fonction de déchiffrage


#endif

//codage.cpp

#include"codage.h"


void choix0(std::string& a)
{
	std::string temporaire="";
	srand(time(0));
        short int choix(rand()%2);
	if (choix==0)
	{
		temporaire+='M';
	}
	else
	{
		temporaire+='0';
	}
	for(unsigned int i=0;i':
		a[i]='~';
		break;

		case '\n':
		break;


		default:
		std::cout<<"Attention: un caractère n'a pas été reconnu... Abandon.\n";
		break;
		    }
	}
}


void choix1(std::string& a)
{	
	std::string temporaire="";
	srand(time(0));
        short int choix(rand()%2);
	if (choix==0)
	{
		temporaire+='L';
	}
	else
	{
		temporaire+='1';
	}
	for(unsigned int i=0;i':
			a[i]=',';
			break;

			case '\n':
			break;

			default:
			std::cout<<"Attention: un caractère n'a pas été reconnu... Abandon.\n";
			break;
		}
	}
}


void choix2(std::string& a)
{
	std::string temporaire="";
	srand(time(0));
        short int choix(rand()%2);
	if (choix==0)
	{
		temporaire+='j';
	}
	else
	{
		temporaire+='2';
	}
	for(unsigned int i=0;i':
			a[i]='?';
			break;

			case '\n':
			break;

			default:
			std::cout<<"Attention: un caractère n'a pas été reconnu... Abandon.\n";
			break;
		}

    	}
}


void choix3(std::string& a)
{
	std::string temporaire="";
	srand(time(0));
        short int choix(rand()%2);
	if (choix==0)
	{
		temporaire+='!';
	}
	else
	{
		temporaire+='3';
	}
	for(unsigned int i=0;i':
			a[i]='o';
			break;

			case '\n':
			break;

			default:
			std::cout<<"Attention: un caractère n'a pas été reconnu... Abandon.\n";
			break;
		}
	}
}


void choix4(std::string& a)
{
	std::string temporaire="";
	srand(time(0));
        short int choix(rand()%2);
	if (choix==0)
	{
		temporaire+='b';
	}
	else
	{
		temporaire+='4';
	}
	for(unsigned int i=0;i':
			a[i]='j';
			break;

			case '\n':
			break;

			default:
			std::cout<<"Attention: un caractère n'a pas été reconnu... Abandon.\n";
			break;
		}
	}
}


void decode(std::string& a)
{
	if(a[0]=='0' || a[0]=='M')
	{
		for(unsigned int i=1; i':
				a[i]='o';
				break;

				case ':':
				a[i]='p';
				break;

				case '\\':
				a[i]='q';
				break;

				case 'X':
				a[i]='r';
				break;

				case 'n':
				a[i]='s';
				break;

				case 'd':
				a[i]='t';
				break;

				case 'I':
				a[i]='u';
				break;

				case 'T':
				a[i]='v';
				break;

				case 'Y':
				a[i]='w';
				break;

				case 'f':
				a[i]='x';
				break;

				case 'v':
				a[i]='y';
				break;

				case 'R':
				a[i]='z';
				break;

				case '&':
				a[i]=' ';
				break;

				case 'g':
				a[i]='0';
				break;

				case '{':
				a[i]='1';
				break;

				case '4':
				a[i]='2';
				break;

				case '(':
				a[i]='3';
				break;

				case 'H':
				a[i]='4';
				break;

				case '-':
				a[i]='5';
				break;

				case 'j':
				a[i]='6';
				break;

				case 'N':
				a[i]='7';
				break;

				case 'C':
				a[i]='8';
				break;

				case 'c':
				a[i]='9';
				break;

				case '+':
				a[i]='A';
				break;

				case 'O':
				a[i]='B';
				break;

				case '"':
				a[i]='C';
				break;

				case 'e':
				a[i]='D';
				break;

				case 'u':
				a[i]='E';
				break;

				case 'D':
				a[i]='F';
				break;

				case '0':
				a[i]='G';
				break;

				case 't':
				a[i]='H';
				break;

				case 'x':
				a[i]='I';
				break;

				case 'K':
				a[i]='J';
				break;

				case '_':
				a[i]='K';
				break;

				case 's':
				a[i]='L';
				break;

				case '7':
				a[i]='M';
				break;

				case 'F':
				a[i]='N';
				break;

				case 'm':
				a[i]='O';
				break;

				case '6':
				a[i]='P';
				break;

				case 'L':
				a[i]='Q';
				break;

				case 'S':
				a[i]='R';
				break;

				case 'B':
				a[i]='S';
				break;

				case 'G':
				a[i]='T';
				break;

				case '}':
				a[i]='U';
				break;

				case '5':
				a[i]='V';
				break;

				case 'y':
				a[i]='W';
				break;

				case 'h':
				a[i]='X';
				break;

				case ']':
				a[i]='Y';
				break;

				case 'Q':
				a[i]='Z';
				break;

				case 'V':
				a[i]='&';
				break;

				case '?':
				a[i]='"';
				break;

				case '8':
				a[i]='\'';
				break;

				case 'r':
				a[i]='(';
				break;

				case 'w':
				a[i]='-';
				break;

				case 'i':
				a[i]='_';
				break;

				case ')':
				a[i]=')';
				break;

				case 'a':
				a[i]='=';
				break;

				case ' ':
				a[i]='+';
				break;

				case 'z':
				a[i]='#';
				break;

				case 'P':
				a[i]='{';
				break;

				case '9':
				a[i]='[';
				break;

				case 'o':
				a[i]='|';
				break;

				case ';':
				a[i]='\\';
				break;

				case '<':
				a[i]='@';
				break;

				case ',':
				a[i]=']';
				break;

				case 'E':
				a[i]='}';
				break;

				case '$':
				a[i]='$';
				break;

				case 'J':
				a[i]=',';
				break;

				case '!':
				a[i]=';';
				break;

				case '.':
				a[i]=':';
				break;

				case '#':
				a[i]='!';
				break;

				case '[':
				a[i]='%';
				break;

				case '=':
				a[i]='?';
				break;

				case 'M':
				a[i]='~';
				break;

				case '%':
				a[i]='.';
				break;

				case 'W':
				a[i]='/';
				break;

				case 'p':
				a[i]='<';
				break;

				case '~':
				a[i]='>';
				break;

				case '\n':
				break;

				default:
				std::cout<<"Attention: un caractère n'a pas été reconnu... Abandon.\n";
				break;
			}
    		}
	}
        else if(a[0]=='1' || a[0]=='L')
	{
			for(unsigned int i=1; i':
					a[i]=':';
					break;

					case 'm':
					a[i]='!';
					break;

					case '\\':
					a[i]='%';
					break;

					case 'j':
					a[i]='?';
					break;

					case 'P':
					a[i]='~';
					break;

					case '"':
					a[i]='.';
					break;

					case 'X':
					a[i]='/';
					break;

					case 'M':
					a[i]='<';
					break;

					case ',':
					a[i]='>';
					break;

					case '\n':
					break;

					default:
					std::cout<<"Attention: un caractère n'a pas été reconnu... Abandon.\n";
					break;
			}
		}
	}
	else if(a[0]=='2' || a[0]=='j')
	{
			for(unsigned int i=1; i':
					a[i]='u';
					break;

					case ';':
					a[i]='v';
					break;

					case 'X':
					a[i]='w';
					break;

					case 'u':
					a[i]='x';
					break;

					case '2':
					a[i]='y';
					break;

					case '}':
					a[i]='z';
					break;

					case '=':
					a[i]=' ';
					break;

					case 'n':
					a[i]='0';
					break;

					case ']':
					a[i]='1';
					break;

					case '#':
					a[i]='2';
					break;

					case 'M':
					a[i]='3';
					break;

					case '{':
					a[i]='4';
					break;

					case '8':
					a[i]='5';
					break;

					case '9':
					a[i]='6';
					break;

					case 'k':
					a[i]='7';
					break;

					case '.':
					a[i]='8';
					break;

					case '&':
					a[i]='9';
					break;

					case 'b':
					a[i]='A';
					break;

					case 'Z':
					a[i]='B';
					break;

					case ':':
					a[i]='C';
					break;

					case '~':
					a[i]='D';
					break;

					case '!':
					a[i]='E';
					break;

					case ')':
					a[i]='F';
					break;

					case 'V':
					a[i]='G';
					break;

					case '+':
					a[i]='H';
					break;

					case 'O':
					a[i]='I';
					break;

					case 'p':
					a[i]='J';
					break;

					case 'W':
					a[i]='K';
					break;

					case 'y':
					a[i]='L';
					break;

					case 'm':
					a[i]='M';
					break;

					case 'h':
					a[i]='N';
					break;

					case '-':
					a[i]='O';
					break;

					case 't':
					a[i]='P';
					break;

					case 's':
					a[i]='Q';
					break;

					case '"':
					a[i]='R';
					break;

					case 'w':
					a[i]='S';
					break;

					case 'B':
					a[i]='T';
					break;

					case 'J':
					a[i]='U';
					break;

					case '[':
					a[i]='V';
					break;

					case '_':
					a[i]='W';
					break;

					case 'K':
					a[i]='X';
					break;

					case 'q':
					a[i]='Y';
					break;

					case '6':
					a[i]='Z';
					break;

					case 'r':
					a[i]='&';
					break;

					case ',':
					a[i]='"';
					break;

					case 'E':
					a[i]='\'';
					break;

					case 'G':
					a[i]='(';
					break;

					case '0':
					a[i]='-';
					break;

					case '1':
					a[i]='_';
					break;

					case 'F':
					a[i]=')';
					break;

					case 'L':
					a[i]='=';
					break;

					case '@':
					a[i]='+';
					break;

					case 'c':
					a[i]='#';
					break;

					case '\'':
					a[i]='{';
					break;

					case 'o':
					a[i]='[';
					break;

					case 'U':
					a[i]='|';
					break;

					case 'x':
					a[i]='\\';
					break;

					case '|':
					a[i]='@';
					break;

					case '7':
					a[i]=']';
					break;

					case '<':
					a[i]='}';
					break;

					case 'S':
					a[i]='$';
					break;

					case 'g':
					a[i]=',';
					break;

					case '4':
					a[i]=';';
					break;

					case ' ':
					a[i]=':';
					break;

					case 'H':
					a[i]='!';
					break;

					case 'i':
					a[i]='%';
					break;

					case 'j':
					a[i]='?';
					break;

					case '%':
					a[i]='~';
					break;

					case '(':
					a[i]='.';
					break;

					case 'l':
					a[i]='/';
					break;

					case '\\':
					a[i]='<';
					break;

					case '?':
					a[i]='>';
					break;

					case '\n':
					break;

					default:
					std::cout<<"Attention: un caractère n'a pas été reconnu... Abandon.\n";
					break;
				}
			}
		}
		else if(a[0]=='3' || a[0]=='!')
		{
			for(unsigned int i=1; i':
					a[i]='J';
					break;

					case 'Z':
					a[i]='K';
					break;

					case 'K':
					a[i]='L';
					break;

					case '{':
					a[i]='M';
					break;

					case '_':
					a[i]='N';
					break;

					case ']':
					a[i]='O';
					break;

					case 'r':
					a[i]='P';
					break;

					case 'U':
					a[i]='Q';
					break;

					case '?':
					a[i]='R';
					break;

					case '&':
					a[i]='S';
					break;

					case 'k':
					a[i]='T';
					break;

					case '#':
					a[i]='U';
					break;

					case '!':
					a[i]='V';
					break;

					case '8':
					a[i]='W';
					break;

					case 'B':
					a[i]='X';
					break;

					case 'I':
					a[i]='Y';
					break;

					case 'R':
					a[i]='Z';
					break;

					case '}':
					a[i]='&';
					break;

					case '3':
					a[i]='"';
					break;

					case 'M':
					a[i]='\'';
					break;

					case 'i':
					a[i]='(';
					break;

					case 'e':
					a[i]='-';
					break;

					case 'm':
					a[i]='_';
					break;

					case '-':
					a[i]=')';
					break;

					case '=':
					a[i]='=';
					break;

					case '"':
					a[i]='+';
					break;

					case 'S':
					a[i]='#';
					break;

					case '@':
					a[i]='{';
					break;

					case '/':
					a[i]='[';
					break;

					case 'n':
					a[i]='|';
					break;

					case '6':
					a[i]='\\';
					break;

					case '5':
					a[i]='@';
					break;

					case ';':
					a[i]=']';
					break;

					case 'b':
					a[i]='}';
					break;

					case 'l':
					a[i]='$';
					break;

					case ',':
					a[i]=',';
					break;

					case 'j':
					a[i]=';';
					break;

					case '$':
					a[i]=':';
					break;

					case '|':
					a[i]='!';
					break;

					case 'C':
					a[i]='%';
					break;

					case '(':
					a[i]='?';
					break;

					case 'z':
					a[i]='~';
					break;

					case '<':
					a[i]='.';
					break;

					case 'L':
					a[i]='/';
					break;

					case 's':
					a[i]='<';
					break;

					case 'o':
					a[i]='>';
					break;

					case '\n':
					break;

					default:
					std::cout<<"Attention: un caractère n'a pas été reconnu... Abandon.\n";
					break;
				}
			}
		}
		else if(a[0]=='4' || a[0]=='b')
		{
			for(unsigned int i=1; i':
					a[i]=',';
					break;

					case ':':
					a[i]=';';
					break;

					case 'J':
					a[i]=':';
					break;

					case '|':
					a[i]='!';
					break;

					case 'a':
					a[i]='%';
					break;

					case 'y':
					a[i]='?';
					break;

					case 'v':
					a[i]='~';
					break;

					case 'e':
					a[i]='.';
					break;

					case '/':
					a[i]='/';
					break;

					case 'q':
					a[i]='<';
					break;

					case 'j':
					a[i]='>';
					break;

					case '\n':
					break;

					default:
					std::cout<<"Attention: un caractère n'a pas été reconnu... Abandon.\n";
					break;
				}
			}
		}
		else
		{
			std::cout<<"Erreur: encodage non reconnu.\n";
		}
}

//header.h

#ifndef header
#define header

#include
#include
#include
#include
#include
#include
#include
#include

#include"action.h"
#include"codage.h"

#endif

//header.cpp

#include"header.h"

Sources de Encryptor:

//mains.cpp

#include 
#include 
#include 
#include "fonctions.h"
#include "menus.h"
#include "cryptage.h"


int main()
{
    //Declaration des variables
    bool quit = 0; // Variable de la Boucle Principale
    char menu = '0'; // Choix de l'utilisateur dans le switch

    clrscreen();
    //Boucle principale
    while(quit != 1)
    {
        //Menu Principal
        std::cout << "Menu Principal\n";
        std::cout << "===============\n\n";
        std::cout << "1. Cryptage\n\n";
        std::cout << "2. A propos\n";
        std::cout << "3. Quitter\n";
        std::cout << "===============\n";
        std::cout << "Choix ? ";
        std::cin >> menu; // l'utilisateur entre le menu qu'il souhaite ouvrir

        //Redirection de l'utilisateur selon son choix grâce à un switch.
        switch(menu)
        {
            case '1':
                clrscreen();
                menuCryptage(); //On ouvre le menu de cryptage/decryptage
                break;
            case '2':
                clrscreen();
                menuAbout();    //on ouvre le menu "A propos"
                break;
            case '3':
                clrscreen();
                menuVerify(quit);   //on demande une confirmation avant de quitter
                break;
            default:
                clrscreen();
                std::cout << "/!\\ Entree Invalide /!\\\n\n";
                break;
        }

    }
    return 0;
}

//menus.h

#ifndef MENUS_H_INCLUDED
#define MENUS_H_INCLUDED

void menuCrypter();
void menuDecrypter();
void menuCryptage();
void menuOptions();
bool menuVerify(bool &quit);
void menuAbout();
void menuChoixHashage();

#endif // MENUS_H_INCLUDED

//menus.cpp

#include 
#include 
#include 
#include 
#include "fonctions.h"
#include "menus.h"
#include "cryptage.h"


void menuCryptage()
{
    //Declaration des variables
    bool retour = 0; // Variable de la Boucle Principale
    char menu = '0'; // Choix de l'utilisateur dans le switch

    //avant d'entrer dans le menu on flushe l'ecran
    clrscreen();
    //Boucle principale
    while(retour != 1)
    {
        //Menu Principal
        std::cout << "Menu Cryptage\n";
        std::cout << "===============\n\n";
        std::cout << "1. Crypter\n";
        std::cout << "2. Decrypter\n\n";
        std::cout << "3. Retour\n";
        std::cout << "===============\n";
        std::cout << "Choix ? ";
        std::cin >> menu; // l'utilisateur entre le menu qu'il souhaite ouvrir

        //Redirection de l'utilisateur selon son choix grâce à un switch.
        switch(menu)
        {
            case '1':
                clrscreen();
                menuCrypter();
                break;
            case '2':
                clrscreen();
                menuDecrypter();

                break;
            case '3':
                clrscreen();
                retour = 1;
                break;
            default:
                clrscreen();
                std::cout << "/!\\ Entree Invalide /!\\\n\n";
                break;
        }

    }
}

void menuCrypter()
{
        //Declaration des variables
    bool retour = 0; // Variable de la Boucle Principale
    char menu = '0'; // Choix de l'utilisateur dans le switch
    std::string path = "na";

    //avant d'entrer dans le menu on flushe l'ecran
    clrscreen();
    //Boucle principale
    while(retour != 1)
    {
        //Menu Principal
        std::cout << "Crypter un Fichier\n";
        std::cout << "===============\n";
        std::cout << "1. Choix du Hashage [Actuel : " << currentHash() << "]\n\n";
        std::cout << "2. Creer un fichier crypte\n";
        std::cout << "3. Crypter un fichier\n\n";
        std::cout << "4. Retour\n";
        std::cout << "===============\n";
        std::cout << "Choix ? ";
        std::cin >> menu; // l'utilisateur entre le menu qu'il souhaite ouvrir

        //Redirection de l'utilisateur selon son choix grâce à un switch.
        switch(menu)
        {
        case '1':
            clrscreen();
            menuChoixHashage();
            break;
        case '2':
            clrscreen();
            path = createTxt();
            choixHashage(getHashNum(), path);
            break;
        case '3':
            clrscreen();
            std::cout << "Cryptage d'un fichier\n";
            std::cout << "===============\n\n";
            std::cout << "Entrez le chemin jusqu'au fichier a crypter :\n";
            std::cout << "(ex: C:/Secret/fichier.txt)\n\n";
            std::cout << "-| ";
            std::cin.ignore(std::numeric_limits::max(),'\n');
            std::getline(std::cin, path);
            choixHashage(getHashNum(), path);
            break;
        case '4':
            clrscreen();
            retour = 1;
            break;
            default:
            clrscreen();
            std::cout << "/!\\ Entree Invalide /!\\\n\n";
            break;
        }

    }
}

void menuDecrypter()
{
        //Declaration des variables
    bool retour = 0; // Variable de la Boucle Principale
    char menu = '0'; // Choix de l'utilisateur dans le switch
    std::string path = "na";

    //avant d'entrer dans le menu on flushe l'ecran
    clrscreen();
    //Boucle principale
    while(retour != 1)
    {
        //Menu Principal
        std::cout << "Decrypter un Fichier\n";
        std::cout << "===============\n\n";
        std::cout << "1. Decrypter un fichier\n\n";
        std::cout << "2. Retour\n";
        std::cout << "===============\n";
        std::cout << "Choix ? ";
        std::cin >> menu; // l'utilisateur entre le menu qu'il souhaite ouvrir

        //Redirection de l'utilisateur selon son choix grâce à un switch.
        switch(menu)
        {
            case '1':
                clrscreen();
                std::cout << "Decrypter un Fichier\n";
                std::cout << "===============\n\n";
                std::cout << "Entrez le chemin jusqu'au fichier a decrypter :\n";
                std::cout << "(ex: C:/Secret/fichier.txt.cdx)\n\n";
                std::cout << "-| ";
                std::cin.ignore(std::numeric_limits::max(),'\n');
                std::getline(std::cin, path);
                getDecryptHash(path);
                break;
            case '2':
                clrscreen();
                retour = 1;
                break;
            default:
                clrscreen();
                std::cout << "/!\\ Entree Invalide /!\\\n\n";
                break;
        }

    }
}

void menuOptions()
{
    //Declaration des variables
    bool retour = 0; // Variable de la Boucle Principale
    char menu = '0'; // Choix de l'utilisateur dans le switch

    //avant d'entrer dans le menu on flush l'ecran
    clrscreen();
    //Boucle principale
    while(retour != 1)
    {
        //Menu Principal
        std::cout << "Parametres\n";
        std::cout << "===============\n\n";
        std::cout << "1. Changer la Table de Hashage\n";
        std::cout << "2. Reinitialiser les reglages\n\n";
        std::cout << "3. Retour\n";
        std::cout << "===============\n";
        std::cout << "Choix ? ";
        std::cin >> menu; // l'utilisateur entre le menu qu'il souhaite ouvrir

        //Redirection de l'utilisateur selon son choix grâce à un switch, et on vérifie que menu ne contienne pas n'importequoi
        switch(menu)
        {
        case '1': //pour menu = 1
            clrscreen();
            menuChoixHashage();
            break;
        case '2': // pour menu = 2
            clrscreen();
            setHashHSH();
            break;
        case '3': // pour menu = 3
            clrscreen();
            retour = 1;
            break;
        default:
            clrscreen();
            std::cout << "/!\\ Entree Invalide /!\\\n\n";
            break;
        }


    }
}

void menuChoixHashage()
{
    //Declaration des variables
    bool retour = 0; // Variable de la Boucle Principale
    char menu = '0'; // Choix de l'utilisateur dans le switch

    //avant d'entrer dans le menu on flush l'ecran
    clrscreen();
    //Boucle principale
    while(retour != 1)
    {
        //Menu Principal
        std::cout << "Choix de la table de hashage\n";
        std::cout << "===============\n";
        std::cout << "Table de Hashage Actuelle : [" << currentHash() << "]\n\n";
        std::cout << "1. Utiliser le Hashage [HSH%]\n";
        std::cout << "2. Utiliser le Hashage [EXP+]\n\n";
        std::cout << "3. Retour\n";
        std::cout << "===============\n";
        std::cout << "Choix ? ";
        std::cin >> menu; // l'utilisateur entre le menu qu'il souhaite ouvrir

        //Redirection de l'utilisateur selon son choix grâce à un switch, et on vérifie que menu ne contienne pas n'importequoi
        switch(menu)
        {
        case '1': //pour menu = 1
            clrscreen();
            setHashHSH();
            std::cout << "/!\\ Hashage Modifie /!\\\n\n";
            break;
        case '2': // pour menu = 2
            clrscreen();
            setHashEXP();
            std::cout << "/!\\ Hashage Modifie /!\\\n\n";
            break;
        case '3': // pour menu = 3
            clrscreen();
            retour = 1;
            break;
        default:
            clrscreen();
            std::cout << "/!\\ Entree Invalide /!\\\n\n";
            break;
        }


    }
}

bool menuVerify(bool& quit)
{
    char quitVerify = 'x'; // variable de confirmation
    while(quitVerify != 'n') // Boucle de confirmation
                {
                    std::cout << "Merci d'utiliser Encryptor !\n";
                    std::cout << "====================\n\n";
                    std::cout << "Souhaitez-vous vraiment quitter ? [o/n]\n";
                    std::cin >> quitVerify;
                    switch(quitVerify)
                    {
                        case 'o':
                            quitVerify = 'n'; // on quitte la vérification
                            quit = 1; //on quitte le programme
                            break;

                        case 'n':
                            clrscreen(); // la verification prend la valeur n donc on sort de la vérification, mais quit est toujours égal a 0
                            break;
                        default:
                            clrscreen();
                            std::cout << "/!\\ Entree Invalide /!\\\n\n";
                            break;
                    }
                }
    return quit;
}


void menuAbout()
{
    //Declaration des variables
    bool retour = 0; // Variable de la Boucle Principale
    char menu = '0'; // Choix de l'utilisateur dans le switch

    //avant d'entrer dans le menu on flushe l'ecran
    clrscreen();
    //Boucle principale
    while(retour != 1)
    {
        //Menu Principal
        std::cout << "A Propos d'Encryptor\n";
        std::cout << "===============\n\n";
        std::cout << "Encryptor est un logiciel de cryptage de fichiers en console\nCe logiciel est developpe en C++ par Stalker2106\n(contact: Stalker2106x@gmail.com)\n\nLa version actuelle du programme est [Encryptor " << getVersion() << "]\n\n";
        std::cout << "1. Retour\n";
        std::cout << "===============\n";
        std::cout << "Choix ? ";
        std::cin >> menu; // l'utilisateur entre le menu qu'il souhaite ouvrir

        //Redirection de l'utilisateur selon son choix grâce à un switch.
        switch(menu)
        {
            case '1':
                clrscreen();
                retour = 1;
                break;
            default:
                clrscreen();
                std::cout << "/!\\ Entree Invalide /!\\\n\n";
                break;
        }

    }
}

//cryptage.h

#ifndef CRYPTAGE_H_INCLUDED
#define CRYPTAGE_H_INCLUDED

void hashageHSH(std::string path);
void deHashageHSH(std::string path);
void hashageEXP(std::string path);
void deHashageEXP(std::string path);
#endif // CRYPTAGE_H_INCLUDED

//cryptage.cpp

#include 
#include 
#include 
#include 
#include "fonctions.h"
#include "menus.h"
#include "cryptage.h"

/*
 * Le cryptage HSH remplace un caractère par un entier composé de 3 chiffres en base 10.
 * Ici le hashage est effectué grace à une Boucle for qui utilise un switch comme dictionnaire de définition.
 */


void hashageHSH(std::string path)
{
    //variables de codage
    char lettre = '.'; //variable qui contient la lettre actuellement en lecture.
    short int code = 0; // variable qui contient le caractère crypté

    //variable de sécurité
    char isCrypted = '.'; //variable testant si le fichier est déja crypté ou non.

    //Variables de chemin du systeme de fichier
    std::string file = "na"; //variable qui récupere le chemin fourni par l'utilisateur
    std::string line = "na"; //variable contenant la ligne actuellement lue
    std::string filex = "na"; //variable contenant le chemin du fichier crypté

    //Definition des chemins du systeme de fichier qui seront utilisés.
    file = path; // récuperation du chemin entré par l'utilisateur
    filex = file + ".hsh"; //on crée un fichier ".cdx" contenant le fichier codé.
    std::ifstream read(file.c_str()); //Flux de lecture du fichier non crypté

    if(read)
    {
    //Tout est prêt pour la lecture.
    std::cout << "L'ouverture du fichier " << path << " s'est correctement deroulee.\n\n";

    // On vérifie que le fichier ne soit pas déja crypté
    isCrypted = read.get(); //On récupère le premier caractère du fichier

        if(isCrypted == '*') // Si il est déja crypté on affiche une erreur
        {
            std::cout << "ERREUR: Le fichier slectionne est deja crypte.\n\n";
        }
        else //Sinon on peut commencer les opérations de cryptage
        {
            std::ofstream write(filex.c_str()); // Flux d'ecriture du fichier crypté
            read.seekg(0, std::ios::beg);
            write << "*";
            while(getline(read, line)) //Tant qu'on n'est pas à la fin du fichier, on lit
            {
                for(unsigned short int i = 0; i < line.size(); i++) //Tant qu'on est pas a la fin de la ligne, on crypte
                {
                    lettre = line[i]; //on stocke la lettre lue dans la variable lettre.

                    //CODAGE HSH
                    switch(lettre) // on assigne pour chaque valeur de lettre un code a 3 caractères, et on l'inscrit dans le fichier
                    {
                    case '.':
                        code = 100;
                        break;
                    case 'a':
                        code = 101;
                        break;
                    case 'b':
                        code = 102;
                        break;
                    case 'c':
                        code = 103;
                        break;
                    case 'd':
                        code = 104;
                        break;
                    case 'e':
                        code = 105;
                        break;
                    case 'f':
                        code = 106;
                        break;
                    case 'g':
                        code = 107;
                        break;
                    case 'h':
                        code = 108;
                        break;
                    case 'i':
                        code = 109;
                        break;
                    case 'j':
                        code = 110;
                        break;
                    case 'k':
                        code = 111;
                        break;
                    case 'l':
                        code = 112;
                        break;
                    case 'm':
                        code = 113;
                        break;
                    case 'n':
                        code = 114;
                        break;
                    case 'o':
                        code = 115;
                        break;
                    case 'p':
                        code = 116;
                        break;
                    case 'q':
                        code = 117;
                        break;
                    case 'r':
                        code = 118;
                        break;
                    case 's':
                        code = 119;
                        break;
                    case 't':
                        code = 120;
                        break;
                    case 'u':
                        code = 121;
                        break;
                    case 'v':
                        code = 122;
                        break;
                    case 'w':
                        code = 123;
                        break;
                    case 'x':
                        code = 124;
                        break;
                    case 'y':
                        code = 125;
                        break;
                    case 'z':
                        code = 126;
                        break;
                    case '-':
                        code = 127;
                        break;
                    case '(':
                        code = 128;
                        break;
                    case ')':
                        code = 129;
                        break;
                    case '"':
                        code = 130;
                        break;
                    case 'A':
                        code = 131;
                        break;
                    case 'B':
                        code = 132;
                        break;
                    case 'C':
                        code = 133;
                        break;
                    case 'D':
                        code = 134;
                        break;
                    case 'E':
                        code = 135;
                        break;
                    case 'F':
                        code = 136;
                        break;
                    case 'G':
                        code = 137;
                        break;
                    case 'H':
                        code = 138;
                        break;
                    case 'I':
                        code = 139;
                        break;
                    case 'J':
                        code = 140;
                        break;
                    case 'K':
                        code = 141;
                        break;
                    case 'L':
                        code = 142;
                        break;
                    case 'M':
                        code = 143;
                        break;
                    case 'N':
                        code = 144;
                        break;
                    case 'O':
                        code = 145;
                        break;
                    case 'P':
                        code = 146;
                        break;
                    case 'Q':
                        code = 147;
                        break;
                    case 'R':
                        code = 148;
                        break;
                    case 'S':
                        code = 149;
                        break;
                    case 'T':
                        code = 150;
                        break;
                    case 'U':
                        code = 151;
                        break;
                    case 'V':
                        code = 152;
                        break;
                    case 'W':
                        code = 153;
                        break;
                    case 'X':
                        code = 154;
                        break;
                    case 'Y':
                        code = 155;
                        break;
                    case 'Z':
                        code = 156;
                        break;
                    case '0':
                        code = 157;
                        break;
                    case '1':
                        code = 158;
                        break;
                    case '2':
                        code = 159;
                        break;
                    case '3':
                        code = 160;
                        break;
                    case '4':
                        code = 161;
                        break;
                    case '5':
                        code = 162;
                        break;
                    case '6':
                        code = 163;
                        break;
                    case '7':
                        code = 164;
                        break;
                    case '8':
                        code = 165;
                        break;
                    case '9':
                        code = 166;
                        break;
                    case '!':
                        code = 167;
                        break;
                    case '#':
                        code = 168;
                        break;
                    case '$':
                        code = 169;
                        break;
                    case '%':
                        code = 170;
                        break;
                    case '&':
                        code = 171;
                        break;
                    case '*':
                        code = 172;
                        break;
                    case '+':
                        code = 173;
                        break;
                    case '/':
                        code = 174;
                        break;
                    case '\\':
                        code = 175;
                        break;
                    case '[':
                        code = 176;
                        break;
                    case ']':
                        code = 177;
                        break;
                    case '^':
                        code = 178;
                        break;
                    case '_':
                        code = 179;
                        break;
                    case '{':
                        code = 180;
                        break;
                    case '|':
                        code = 181;
                        break;
                    case '}':
                        code = 182;
                        break;
                    case '~':
                        code = 183;
                        break;
                    case ' ':
                        code = 184;
                        break;
                    case ',':
                        code = 185;
                        break;
                    case ';':
                        code = 186;
                        break;
                    case ':':
                        code = 187;
                        break;
                    case 39: //Cas particulier, pour une apostrophe on dit que lettre = 39
                        code = 188;
                        break;
                    case '<':
                        code = 189;
                        break;
                    case '>':
                        code = 190;
                        break;
                    case '@':
                        code = 191;
                        break;
                    case '?':
                        code = 192;
                        break;
                    case '=':
                        code = 193;
                        break;
                    default:
                        code = 999;
                        break;
                    }
                write << code;
                }
                write << "\n";
             }
        }
        clrscreen(); //fin du cryptage, toutes les opérations sont terminées
        std::cout << " CRYPTAGE EFFECTUE \n\n";
    }
    else
    {
        clrscreen(); // le fichier n'existe pas, ou n'a pas pu être ouvert
        std::cout << "ERREUR: Impossible d'ouvrir le fichier en lecture.\n";
        std::cout << "Verifiez que vous avez correctement entre le chemin du fichier\n\n";
    }
}

void deHashageHSH(std::string path)
{
    char lettre = '.'; //variable contenant la lettre qui sera décodée
    char isCrypted = '.'; //on vérifie que le fichier soit crypté
    std::string codex1 = "0"; // 1er chiffre du code
    std::string codex2 = "0"; // 2nd chiffre du code
    std::string codex3 = "0"; // 3eme chiffre du code

    std::string codeCat = "0";
    short int code = 0; //code complet

    std::string filex = "na"; //variable qui récupere le chemin fourni par l'utilisateur
    std::string file = "na"; //variable contenant le chemin du fichier décrypté

    std::string line = "na"; //variable contenant la ligne actuellement en lecture



    filex = path; // récuperation du chemin entré par l'utilisateur
    file = filex.substr(0, filex.size() - 4); //on crée un fichier ".cdx" contenant le fichier décodé.
    std::ifstream read(filex.c_str()); //Flux de lecture du fichier non crypté

    if(read)
    {
    //Tout est prêt pour la lecture.
        std::cout << "L'ouverture du fichier " << path << " s'est correctement deroulee.\n\n";

        isCrypted = read.get(); //On récupère le premier caractère du fichier

        if(isCrypted != '*')
        {
            std::cout << "ERREUR: Le fichier selectionne n'est pas crypte.\n\n";
        }
        else
        {
            std::ofstream write(file.c_str()); // Flux d'ecriture du fichier crypté
            while(getline(read, line)) //Tant qu'on n'est pas à la fin, on lit
            {
                for(unsigned int i = 0; i < line.size(); i++)
                {
                    codex1 = line[i]; //on lit le premier caractère et on le stocke dans codex1
                    i++; //comme le curseur a été déplacé d'un cran vers la droite, on incrémente i.
                    codex2 = line[i]; //on lit le second caractère et on le stocke dans codex2
                    i++; //comme le curseur a été déplacé d'un cran vers la droite, on incrémente i.
                    codex3 = line[i]; //on lit le troisieme caractère et on le stocke dans codex3

                    codeCat = codex1 + codex2 + codex3; //On concatène les trois entités du code en une seule string
                    std::istringstream codeConversion(codeCat); // on convertit le code de char vers short int
                    codeConversion >> code; // on inscrit le code converti dans la variable code

                    //DECRYPTAGE
                    switch(code) // on assigne pour chaque code à 3 caractères, une lettre de la table ASCII.
                    {
                    case 100:
                        lettre = '.';
                        break;
                    case 101:
                        lettre = 'a';
                        break;
                    case 102:
                        lettre = 'b';
                        break;
                    case 103:
                        lettre = 'c';
                        break;
                    case 104:
                        lettre = 'd';
                        break;
                    case 105:
                        lettre = 'e';
                        break;
                    case 106:
                        lettre = 'f';
                        break;
                    case 107:
                        lettre = 'g';
                        break;
                    case 108:
                        lettre = 'h';
                        break;
                    case 109:
                        lettre = 'i';
                        break;
                    case 110:
                        lettre = 'j';
                        break;
                    case 111:
                        lettre = 'k';
                        break;
                    case 112:
                        lettre = 'l';
                        break;
                    case 113:
                        lettre = 'm';
                        break;
                    case 114:
                        lettre = 'n';
                        break;
                    case 115:
                        lettre = 'o';
                        break;
                    case 116:
                        lettre = 'p';
                        break;
                    case 117:
                        lettre = 'q';
                        break;
                    case 118:
                        lettre = 'r';
                        break;
                    case 119:
                        lettre = 's';
                        break;
                    case 120:
                        lettre = 't';
                        break;
                    case 121:
                        lettre = 'u';
                        break;
                    case 122:
                        lettre = 'v';
                        break;
                    case 123:
                        lettre = 'w';
                        break;
                    case 124:
                        lettre = 'x';
                        break;
                    case 125:
                        lettre = 'y';
                        break;
                    case 126:
                        lettre = 'z';
                        break;
                    case 127:
                        lettre = '-';
                        break;
                    case 128:
                        lettre = '(';
                        break;
                    case 129:
                        lettre = ')';
                        break;
                    case 130:
                        lettre = '"';
                        break;
                    case 131:
                        lettre = 'A';
                        break;
                    case 132:
                        lettre = 'B';
                        break;
                    case 133:
                        lettre = 'C';
                        break;
                    case 134:
                        lettre = 'D';
                        break;
                    case 135:
                        lettre = 'E';
                        break;
                    case 136:
                        lettre = 'F';
                        break;
                    case 137:
                        lettre = 'G';
                        break;
                    case 138:
                        lettre = 'H';
                        break;
                    case 139:
                        lettre = 'I';
                        break;
                    case 140:
                        lettre = 'J';
                        break;
                    case 141:
                        lettre = 'K';
                        break;
                    case 142:
                        lettre = 'L';
                        break;
                    case 143:
                        lettre = 'M';
                        break;
                    case 144:
                        lettre = 'N';
                        break;
                    case 145:
                        lettre = 'O';
                        break;
                    case 146:
                        lettre = 'P';
                        break;
                    case 147:
                        lettre = 'Q';
                        break;
                    case 148:
                        lettre = 'R';
                        break;
                    case 149:
                        lettre = 'S';
                        break;
                    case 150:
                        lettre = 'T';
                        break;
                    case 151:
                        lettre = 'U';
                        break;
                    case 152:
                        lettre = 'V';
                        break;
                    case 153:
                        lettre = 'W';
                        break;
                    case 154:
                        lettre = 'X';
                        break;
                    case 155:
                        lettre = 'Y';
                        break;
                    case 156:
                        lettre = 'Z';
                        break;
                    case 157:
                        lettre = '0';
                        break;
                    case 158:
                        lettre = '1';
                        break;
                    case 159:
                        lettre = '2';
                        break;
                    case 160:
                        lettre = '3';
                        break;
                    case 161:
                        lettre = '4';
                        break;
                    case 162:
                        lettre = '5';
                        break;
                    case 163:
                        lettre = '6';
                        break;
                    case 164:
                        lettre = '7';
                        break;
                    case 165:
                        lettre = '8';
                        break;
                    case 166:
                        lettre = '9';
                        break;
                    case 167:
                        lettre = '!';
                        break;
                    case 168:
                        lettre = '#';
                        break;
                    case 169:
                        lettre = '$';
                        break;
                    case 170:
                        lettre = '%';
                        break;
                    case 171:
                        lettre = '&';
                        break;
                    case 172:
                        lettre = '*';
                        break;
                    case 173:
                        lettre = '+';
                        break;
                    case 174:
                        lettre = '/';
                        break;
                    case 175:
                        lettre = 92;
                        break;
                    case 176:
                        lettre = '[';
                        break;
                    case 177:
                        lettre = ']';
                        break;
                    case 178:
                        lettre = '^';
                        break;
                    case 179:
                        lettre = '_';
                        break;
                    case 180:
                        lettre = '{';
                        break;
                    case 181:
                        lettre = '|';
                        break;
                    case 182:
                        lettre = '}';
                        break;
                    case 183:
                        lettre = '~';
                        break;
                    case 184:
                        lettre = ' ';
                        break;
                    case 185:
                        lettre = ',';
                        break;
                    case 186:
                        lettre = ';';
                        break;
                    case 187:
                        lettre = ':';
                        break;
                    case 188: //Cas particulier, pour une apostrophe on dit que lettre = 39
                        lettre = 39;
                        break;
                    case 189:
                        lettre = '<';
                        break;
                    case 190:
                        lettre = '>';
                        break;
                    case 191:
                        lettre = '@';
                        break;
                    case 192:
                        lettre = '?';
                        break;
                    case 193:
                        lettre = '=';
                        break;
                    default:
                        lettre = '_';
                        break;
                    }
                write << lettre;
                }
                write << "\n";
             }
        }
        clrscreen(); //Toutes les opérations de decryptage sont terminées
        std::cout << " DECRYPTAGE EFFECTUE \n\n";
    }
    else
    {
        clrscreen(); // il y a eu un probleme lors de l'ouverture du fichier ou son emplacement a mal été saisi
        std::cout << "ERREUR: Impossible d'ouvrir le fichier en lecture.\n";
        std::cout << "Verifiez que vous avez correctement entre le chemin du fichier\n\n";
    }
}

/*
 * Le cryptage EXP substitue un caractère a un autre défini sur la table ASCII.
 * Ici le hashage est effectué grace à une Boucle for qui utilise un switch comme dictionnaire de définition.
 */

void hashageEXP(std::string path)
{
    //variables de codage
    char lettre = '.'; //variable qui contient la lettre actuellement en lecture.
    char code = 0; // variable qui contient le caractère crypté

    //variable de sécurité
    char isCrypted = '.'; //variable testant si le fichier est déja crypté ou non.

    //Variables de chemin du systeme de fichier
    std::string file = "na"; //variable qui récupere le chemin fourni par l'utilisateur
    std::string line = "na"; //variable contenant la ligne actuellement lue
    std::string filex = "na"; //variable contenant le chemin du fichier crypté

    //Definition des chemins du systeme de fichier qui seront utilisés.
    file = path; // récuperation du chemin entré par l'utilisateur
    filex = file + ".exp"; //on crée un fichier ".cdx" contenant le fichier codé.
    std::ifstream read(file.c_str()); //Flux de lecture du fichier non crypté

    if(read)
    {
    //Tout est prêt pour la lecture.
        std::cout << "L'ouverture du fichier " << path << " s'est correctement deroulee.\n\n";

        isCrypted = read.get(); //On récupère le premier caractère du fichier

        if(isCrypted == '*')
        {
            std::cout << "ERREUR: Le fichier slectionne est deja crypte.\n\n";
        }
        else
        {
            std::ofstream write(filex.c_str()); // Flux d'ecriture du fichier crypté
            read.seekg(0, std::ios::beg);
            write << "*";
            while(getline(read, line)) //Tant qu'on n'est pas à la fin, on lit
            {
                for(unsigned short int i = 0; i < line.size(); i++) //Tant qu'on a pas atteint la fin de la ligne, on crypte
                {
                    lettre = line[i]; //on stocke le caractère lu dans la variable lettre.

                    //CRYPTAGE
                    switch(lettre) //On assigne a chaque valeur de lettre, un caractère différent.
                    {
                    case 'a':
                        code = 'j';
                        break;
                    case 'b':
                        code = '%';
                        break;
                    case 'c':
                        code = '@';
                        break;
                    case 'd':
                        code = '4';
                        break;
                    case 'e':
                        code = 'w';
                        break;
                    case 'f':
                        code = 'Y';
                        break;
                    case 'g':
                        code = 'M';
                        break;
                    case 'h':
                        code = 'I';
                        break;
                    case 'i':
                        code = '(';
                        break;
                    case 'j':
                        code = 'c';
                        break;
                    case 'k':
                        code = 39;
                        break;
                    case 'l':
                        code = ';';
                        break;
                    case 'm':
                        code = 'R';
                        break;
                    case 'n':
                        code = 'r';
                        break;
                    case 'o':
                        code = 'T';
                        break;
                    case 'p':
                        code = 'p';
                        break;
                    case 'q':
                        code = '_';
                        break;
                    case 'r':
                        code = 'x';
                        break;
                    case 's':
                        code = ' ';
                        break;
                    case 't':
                        code = 'C';
                        break;
                    case 'u':
                        code = 's';
                        break;
                    case 'v':
                        code = 'm';
                        break;
                    case 'w':
                        code = '1';
                        break;
                    case 'x':
                        code = '6';
                        break;
                    case 'y':
                        code = '~';
                        break;
                    case 'z':
                        code = '\\';
                        break;
                    case ' ':
                        code = 'Q';
                        break;
                    case '0':
                        code = '>';
                        break;
                    case '1':
                        code = 'o';
                        break;
                    case '2':
                        code = '5';
                        break;
                    case '3':
                        code = 'g';
                        break;
                    case '4':
                        code = '3';
                        break;
                    case '5':
                        code = 'a';
                        break;
                    case '6':
                        code = '-';
                        break;
                    case '7':
                        code = 'V';
                        break;
                    case '8':
                        code = 'f';
                        break;
                    case '9':
                        code = 'n';
                        break;
                    case 'A':
                        code = ']';
                        break;
                    case 'B':
                        code = '&';
                        break;
                    case 'C':
                        code = 'k';
                        break;
                    case 'D':
                        code = 'u';
                        break;
                    case 'E':
                        code = 'B';
                        break;
                    case 'F':
                        code = '0';
                        break;
                    case 'G':
                        code = '<';
                        break;
                    case 'H':
                        code = 'q';
                        break;
                    case 'I':
                        code = 'z';
                        break;
                    case 'J':
                        code = '2';
                        break;
                    case 'K':
                        code = 'd';
                        break;
                    case 'L':
                        code = '7';
                        break;
                    case 'M':
                        code = 'v';
                        break;
                    case 'N':
                        code = 'S';
                        break;
                    case 'O':
                        code = 'h';
                        break;
                    case 'P':
                        code = 'A';
                        break;
                    case 'Q':
                        code = '+';
                        break;
                    case 'R':
                        code = 'W';
                        break;
                    case 'S':
                        code = 'e';
                        break;
                    case 'T':
                        code = '=';
                        break;
                    case 'U':
                        code = ')';
                        break;
                    case 'V':
                        code = 'E';
                        break;
                    case 'W':
                        code = 'Z';
                        break;
                    case 'X':
                        code = 'i';
                        break;
                    case 'Y':
                        code = 'y';
                        break;
                    case 'Z':
                        code = 'X';
                        break;
                    case '&':
                        code = '}';
                        break;
                    case '"':
                        code = ':';
                        break;
                    case 39:
                        code = 'U';
                        break;
                    case '(':
                        code = 'H';
                        break;
                    case '-':
                        code = '#';
                        break;
                    case '_':
                        code = 't';
                        break;
                    case ')':
                        code = 'G';
                        break;
                    case '=':
                        code = '?';
                        break;
                    case '+':
                        code = 'l';
                        break;
                    case '#':
                        code = 'O';
                        break;
                    case '{':
                        code = '.';
                        break;
                    case '[':
                        code = '{';
                        break;
                    case '|':
                        code = '9';
                        break;
                    case '\\':
                        code = '!';
                        break;
                    case '@':
                        code = 'F';
                        break;
                    case ']':
                        code = ',';
                        break;
                    case '}':
                        code = 'K';
                        break;
                    case '$':
                        code = '|';
                        break;
                    case ',':
                        code = '/';
                        break;
                    case ';':
                        code = 'b';
                        break;
                    case ':':
                        code = '8';
                        break;
                    case '!':
                        code = '[';
                        break;
                    case '%':
                        code = 'L';
                        break;
                    case '?':
                        code = 'N';
                        break;
                    case '~':
                        code = '$';
                        break;
                    case '.':
                        code = 'D';
                        break;
                    case '/':
                        code = 'P';
                        break;
                    case '<':
                        code = 'J';
                        break;
                    case '>':
                        code = '"';
                        break;
                    default:
                        code = '_';
                        break;
                    }
                write << code;
                }
                write << "\n";
             }
        }
        clrscreen(); //Opérations de cryptage términées
        std::cout << " CRYPTAGE EFFECTUE \n\n";
    }
    else
    {
        clrscreen(); //impossible d'ouvrir le fichier, ou le chemin a mal été saisi
        std::cout << "ERREUR: Impossible d'ouvrir le fichier en lecture.\n";
        std::cout << "Verifiez que vous avez correctement entre le chemin du fichier\n\n";
    }
}


void deHashageEXP(std::string path)
{
    //variables de codage
    char lettre = '.'; //variable qui contient la lettre actuellement en lecture.
    char code = '0'; // variable qui contient le caractère crypté

    //variable de sécurité
    char isCrypted = '.'; //variable testant si le fichier est déja crypté ou non.

    //Variables de chemin du systeme de fichier
    std::string file = "na"; //variable qui récupere le chemin fourni par l'utilisateur
    std::string line = "na"; //variable contenant la ligne actuellement lue
    std::string filex = "na"; //variable contenant le chemin du fichier crypté

    //Definition des chemins du systeme de fichier qui seront utilisés.
    filex = path; // récuperation du chemin entré par l'utilisateur
    file = filex.substr(0, filex.size() - 4); //on crée un fichier ".cdx" contenant le fichier décodé.
    std::ifstream read(filex.c_str()); //Flux de lecture du fichier non crypté

    if(read)
    {
    //Tout est prêt pour la lecture.
    isCrypted = read.get(); //On récupère le premier caractère du fichier
        //on vérifie que le fichier soit bel et bien crypté
        if(isCrypted != '*')
        {
            std::cout << "ERREUR: Le fichier selectionne n'est pas crypte.\n\n";
        }
        else //sinon on commence le décryptage
        {
            std::ofstream write(file.c_str()); // Flux d'ecriture du fichier crypté
            while(getline(read, line)) //Tant qu'on n'est pas à la fin, on lit
            {
                for(unsigned short int i = 0; i < line.size(); i++) //tant qu'on est pas a la fin de la ligne, on décrypte.
                {
                    code = line[i];

                    //DECRYPTAGE
                    switch(code) //on asssocie a chaque valeur de code une lettre.
                    {
                    case 'j':
                        lettre ='a';
                        break;
                    case '%':
                        lettre ='b';
                        break;
                    case '@':
                        lettre ='c';
                        break;
                    case '4':
                        lettre ='d';
                        break;
                    case 'w':
                        lettre ='e';
                        break;
                    case 'Y':
                        lettre ='f';
                        break;
                    case 'M':
                        lettre ='g';
                        break;
                    case 'I':
                        lettre ='h';
                        break;
                    case '(':
                        lettre ='i';
                        break;
                    case 'c':
                        lettre ='j';
                        break;
                    case 39:
                        lettre ='k';
                        break;
                    case ';':
                        lettre ='l';
                        break;
                    case 'R':
                        lettre ='m';
                        break;
                    case 'r':
                        lettre ='n';
                        break;
                    case 'T':
                        lettre ='o';
                        break;
                    case 'p':
                        lettre ='p';
                        break;
                    case '_':
                        lettre ='q';
                        break;
                    case 'x':
                        lettre ='r';
                        break;
                    case ' ':
                        lettre ='s';
                        break;
                    case 'C':
                        lettre ='t';
                        break;
                    case 's':
                        lettre ='u';
                        break;
                    case 'm':
                        lettre ='v';
                        break;
                    case '1':
                        lettre ='w';
                        break;
                    case '6':
                        lettre ='x';
                        break;
                    case '~':
                        lettre ='y';
                        break;
                    case '\\':
                        lettre ='z';
                        break;
                    case 'Q':
                        lettre =' ';
                        break;
                    case '>':
                        lettre ='0';
                        break;
                    case 'o':
                        lettre ='1';
                        break;
                    case '5':
                        lettre ='2';
                        break;
                    case 'g':
                        lettre ='3';
                        break;
                    case '3':
                        lettre ='4';
                        break;
                    case 'a':
                        lettre ='5';
                        break;
                    case '-':
                        lettre ='6';
                        break;
                    case 'V':
                        lettre ='7';
                        break;
                    case 'f':
                        lettre ='8';
                        break;
                    case 'n':
                        lettre ='9';
                        break;
                    case ']':
                        lettre ='A';
                        break;
                    case '&':
                        lettre ='B';
                        break;
                    case 'k':
                        lettre ='C';
                        break;
                    case 'u':
                        lettre ='D';
                        break;
                    case 'B':
                        lettre ='E';
                        break;
                    case '0':
                        lettre ='F';
                        break;
                    case '<':
                        lettre ='G';
                        break;
                    case 'q':
                        lettre ='H';
                        break;
                    case 'z':
                        lettre ='I';
                        break;
                    case '2':
                        lettre ='J';
                        break;
                    case 'd':
                        lettre ='K';
                        break;
                    case '7':
                        lettre ='L';
                        break;
                    case 'v':
                        lettre ='M';
                        break;
                    case 'S':
                        lettre ='N';
                        break;
                    case 'h':
                        lettre ='O';
                        break;
                    case 'A':
                        lettre ='P';
                        break;
                    case '+':
                        lettre ='Q';
                        break;
                    case 'W':
                        lettre ='R';
                        break;
                    case 'e':
                        lettre ='S';
                        break;
                    case '=':
                        lettre ='T';
                        break;
                    case ')':
                        lettre ='U';
                        break;
                    case 'E':
                        lettre ='V';
                        break;
                    case 'Z':
                        lettre ='W';
                        break;
                    case 'i':
                        lettre ='X';
                        break;
                    case 'y':
                        lettre ='Y';
                        break;
                    case 'X':
                        lettre ='Z';
                        break;
                    case '}':
                        lettre ='&';
                        break;
                    case ':':
                        lettre ='"';
                        break;
                    case 'U':
                        lettre = 39;
                        break;
                    case 'H':
                        lettre ='(';
                        break;
                    case '#':
                        lettre ='-';
                        break;
                    case 't':
                        lettre ='_';
                        break;
                    case 'G':
                        lettre =')';
                        break;
                    case '?':
                        lettre ='=';
                        break;
                    case 'l':
                        lettre ='+';
                        break;
                    case 'O':
                        lettre ='#';
                        break;
                    case '.':
                        lettre ='{';
                        break;
                    case '{':
                        lettre ='[';
                        break;
                    case '9':
                        lettre ='|';
                        break;
                    case '!':
                        lettre ='\\';
                        break;
                    case 'F':
                        lettre ='@';
                        break;
                    case ',':
                        lettre =']';
                        break;
                    case 'K':
                        lettre ='}';
                        break;
                    case '|':
                        lettre ='$';
                        break;
                    case '/':
                        lettre =',';
                        break;
                    case 'b':
                        lettre =';';
                        break;
                    case '8':
                        lettre =':';
                        break;
                    case '[':
                        lettre ='!';
                        break;
                    case 'L':
                        lettre ='%';
                        break;
                    case 'N':
                        lettre ='?';
                        break;
                    case '$':
                        lettre ='~';
                        break;
                    case 'D':
                        lettre ='.';
                        break;
                    case 'P':
                        lettre ='/';
                        break;
                    case 'J':
                        lettre ='<';
                        break;
                    case '"':
                        lettre ='>';
                        break;
                    default:
                        lettre = '_';
                        break;
                    }
                write << lettre;
                }
                write << "\n";
             }
        }
        clrscreen(); //toutes les opérations de decryptage sont terminées
        std::cout << " DECRYPTAGE EFFECTUE \n\n";
    }
    else
    {
        clrscreen(); // l'utilisateur a mal entré le chemin du fichier, ou il y a eu une erreur a l'ouverture.
        std::cout << "ERREUR: Impossible d'ouvrir le fichier en lecture.\n";
        std::cout << "Verifiez que vous avez correctement entre le chemin du fichier\n\n";
    }
}

//fonctions.h

#ifndef FONCTIONS_H_INCLUDED
#define FONCTIONS_H_INCLUDED

void clrscreen();
std::string currentHash();
void setHashHSH();
void setHashEXP();
short int getHashNum();
void getDecryptHash(std::string& path);
void choixHashage(short int numHash, std::string& path);
std::string createTxt();
std::string getVersion();

#endif // FONCTIONS_H_INCLUDED

//fonctions.cpp

#include 
#include 
#include 
#include 
#include "fonctions.h"
#include "menus.h"
#include "cryptage.h"

void clrscreen() //Fonction qui flushe l'écran
{
    short int nb = 20;
    for(short int i = 0; i <= nb; i++) //boucle for qui saute 20 lignes
    {
        std::cout << "\n";
    }
}

std::string createTxt() //Fonction qui crée un fichier texte contenant une ligne fournie par l'utilisateur
{
    //declaration des variables
    std::string ligne = ""; // ligne saisie par l'utilisateur
    std::string path = ""; //chemin complet souhaité par l'utilisateur
    std::string chemin = ""; //chemin entré par l'utilisateur
    std::string nomFichier = ""; //Nom du fichier entré par l'utilisateur

    //On demande comment nommer le fichier
    std::cout << "Comment souhaitez vous nommer votre fichier ?\n(Ex: Fichier.txt)\n\n-|";
    std::cin.ignore(std::numeric_limits::max(),'\n');
    std::getline(std::cin, nomFichier);
    clrscreen();

    //On demande dans quel répertoire le placer
    std::cout << "Ou souhaitez vous placer le fichier ?\n(Ex: C:/Documents/ )\n\n-|";
    std::getline(std::cin, chemin);

    // on concatène le chemin complet
    path = chemin + nomFichier; // on concatène les string pour creer un chemin valide
    clrscreen();

    //On indique a l'utilisateur le chamin complet, et on lui demande de saisir sa ligne.
    std::cout << "Le fichier \"" << nomFichier << "\" sera cree dans le repertoire : """ << chemin << """\n(Chemin complet: \"" << path << "\")\n"; //on affiche la saisie a l'utilisateur
    std::cout << "====================\n\n";
    std::cout << "Redigez le message a crypter ci-dessous :\n\n";
    std::getline(std::cin, ligne);
    std::ofstream write(path.c_str());
    write << ligne;
    return path;
}

std::string currentHash() // Fonction qui récupere le hashage actuel dans le fichier Hash.tbl
{
    std::string hashTbl = "Non definie";
    std::ifstream param("Hash.tbl");
    std::getline(param, hashTbl);
    return hashTbl;
}

void setHashHSH() // Fonction qui définit le hashage courant à HSH%
{
    std::string hashTbl = "HSH%";
    std::ofstream param("Hash.tbl");
    param << hashTbl;
}

void setHashEXP() // Fonction qui définit le hashage courant à EXP+
{
    std::string hashTbl = "EXP+";
    std::ofstream param("Hash.tbl");
    param << hashTbl;
}

short int getHashNum() // Fonction qui a chaque type de hashage associe un numéro
{
    std::string Hsh;
    Hsh = currentHash();
    if(Hsh == "HSH%")
    {
        return 1;
    }
    else if(Hsh == "EXP+")
    {
        return 2;
    }
    else
    {
        return 0;
    }

}

void choixHashage(short int numHash, std::string& path) //Fonction qui redirige le codage vers le bon hashage en fonction du numéro
{
                if(numHash == 1)
                {
                    hashageHSH(path);
                }
                else if(numHash == 2)
                {
                    hashageEXP(path);
                }
                else
                {
                    clrscreen();
                    std::cout << "ERREUR: Hashage non defini ou inconnu.\n\n";
                }
}

void getDecryptHash(std::string& path) //Fonction qui récupere l'extension du fichier a décrypter afin de déterminer le hashage nécéssaire au décodage
{
    std::string ext = "";
    ext = path.substr(path.size() - 3, path.size());
    if(ext == "hsh")
    {
        deHashageHSH(path);
    }
    else if(ext == "exp")
    {
        deHashageEXP(path);
    }
    else
    {
        clrscreen();
        std::cout << "ERREUR: Hashage du fichier inconnu / corrompu.\n\n";
    }
}



std::string getVersion() // On récupère la version du programme.
{
    std::string version = "Beta v1.5.2";
    return version;
}

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (tiramiseb) — Mon, 21 Jan 2013 09:31:49 +0000

Ici, Abandon signifie simplement qu'il abandonne la conversion DU caractère en cours

Donc interface incompréhensible, car messages incompréhensibles.

Si le fichier résultat est vide, peut être as tu oublié de l'enregistrer ? Car cela, je suis certain que ça fonctionne.

Si le fichier est vide, c'est que je l'ai enregistré, non ?
Je l'ai refait, là ça a marché. Bizarre.

As tu regardé le texte crypté en appuyant sur 2) ?

En effet, il semble me montrer le texte chiffré.

vous aussi vous êtes passés par des mauvais programmes à vos débuts

Pas avec la prétention de faire du chiffrement.

Bon... nos logiciels de chiffrements sont encore en Beta

Ce sont des logiciels en beta, là-dessus il n'y a aucun doute.
Des logiciels de chiffrement, éventuellement.
De potentiels bons logiciels de chiffrement, il n'y a absolument rien qui le laisse penser.
Ce qui est sûr, c'est que ce sont des logiciels que personne de sensé n'utilisera, vue leur manière de fonctionner et l'opacité complète de leur fonctionnement

Pour l'interface... Je sais pas trop comment améliorer vu qu'il y a plein d'options... je devrais tout mettre dans la même fenêtre ? cela ferait 9 options... 11 avec une prochaine mise à jour. ça ne serait pas très agréable :S

Je l'ai écrit, je le réécris : en faisant une interface avec un prompt, en utilisant la bibliothèque readline.

Et pour être plus précis :
- si vous tenez absolument à faire une interface interactive (c'est super chiant une interface interactive en ligne de commande hein), alors utilisez la bibliothèque readline ;
- si vous voulez faire quelque chose de potentiellement efficace, abandonnez l'interactif et utilisez les arguments de la commande, avec la bibliothèque getopt par exemple.

"Tapez 1 pour X, tapez 2 pour Y", c'est les (mauvais) programmes des années 70/80 qui fonctionnaient comme ça !

Et encore une fois : nous sommes incapables de dire quoi que ce soit sur la sécurité de vos programmes vu qu'on n'en voit pas le code source. Tout ce qu'on peut faire ici, c'est donner des avis sur des interfaces. C'est tout. Si vous voulez des avis sur la sécurité, montrez vos codes sources.

Vous voulez les avis de libristes sur du code ? Montrez des logiciels libres !
Vous voulez les avis de développeurs sur du code ? Montrez des sources !
Vous voulez les avis d'utilisateurs sur une interface utilisateur ? Faites ce que vous faites, montrez une interface et cachez le reste...

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (Destroyers) — Mon, 21 Jan 2013 09:05:55 +0000

CRYPTconsol a une meilleure sécurité que Encryptor par ce qu'il a 5 types d'encodages différents choisis aléatoirement à chaque tentatives de chiffrements. De plus, si tu modifie un fichier chiffré par CRYPTconsol, il le reconnaîtra et jugera ton fichier comme étant corrompu.

 Attention: un caractère n'a pas été reconnu... Abandon.

Ici, Abandon signifie simplement qu'il abandonne la conversion DU caractère en cours: il restera inchangé. du coups, le reste du chiffrage s'est bien déroulé.
Ici, je pense que le caractère non reconnu est le retour chariot que tu as fait en appuyant sur entrée. J'essaie de régler ça.

Si le fichier résultat est vide, peut être as tu oublié de l'enregistrer ? Car cela, je suis certain que ça fonctionne.
As tu regardé le texte crypté en appuyant sur 2) ?

Bon... nos logiciels de chiffrements sont encore en Beta, hein, faut pas trop cracher dessus x)
Et c'est le premier vrai programme qu'on fait tout les deux, ils ne peuvent pas être bon... vous aussi vous êtes passés par des mauvais programmes à vos débuts x)

Pour l'interface... Je sais pas trop comment améliorer vu qu'il y a plein d'options... je devrais tout mettre dans la même fenêtre ? cela ferait 9 options... 11 avec une prochaine mise à jour. ça ne serait pas très agréable :S

Réponse à : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

dummy@example.com (tiramiseb) — Mon, 21 Jan 2013 07:06:38 +0000

Salut,

Sans les sources tu ne pourras avoir aucun retour intéressant.
On ne pourra pas évaluer la qualité d'un programmeur en se basant uniquement sur la façon dont son programme fonctionne.
En plus, distribuer les programmes de cette manière-là est la meilleure façon de les rendre compatibles avec un minimum d'environnements.

Il faut savoir que la programmation dans ce domaine est TRÈS complexe, j'ai lu de nombreux articles sur le sujet, notamment sur les erreurs qu'on fait quand on veut réimplémenter ce genre de choses (surtout qu'il existe déjà des bibliothèques très solides pour ça) - malheureusement je n'ai plus les pointeurs.

Stalker2106 a écrit :

Me pencher sur zenity ? pourquoi pas, ca me permettrait de maitriser l'environnement de fenetres GTK+, cela dit c'était vraiment plus un défi qu'un projet.

Non. Te pencher sur Zenity te permettra de savoir afficher des fenêtres à partir d'un script shell. Rien à voir avec la maîtrise de GTK+, loin de là.

Concernant l'interface de vos logiciels, elles sont toutes les deux chiantes à utiliser.
L'interface d'Encryptor reste plus facile à utiliser, celle de CRYPTconsol est carrément imbitable ; notamment il faut plein de fois faire Entrée...

Extrait de l'interface de CRYPTconsol :

Vous voulez crypter votre texte: ... 
Attention: un caractère n'a pas été reconnu... Abandon.
Votre texte a bien été chiffré.

"abandon" ou alors "bien chiffré" !?
(le fichier résultat est vide, j'imagine que le texte n'a pas bien été chiffré alors... très mauvaise gestion des erreurs)
(mon texte est "toto", je ne vois pas ce qui peut être "pas reconnu" comme caractère, entre "t" et "o")

Vous auriez mieux dû faire un prompt interactif, avec la bibliothèque readline par exemple.

il est évident que CRYPTconsol possède une sécurité supplémentaire a son concurrent direct

Ah ouais ? Cela n'est pas du tout évident pour moi, où est cette sécurité supplémentaire !?

PS: je saigne des yeux quand j'utilise Encryptor, car tu utilises les anglicismes "cryptage", "crypter" et "décrypter" là où tu devrais utiliser "chiffrement", "chiffrer" et "déchiffrer".
Surtout que "décrypter" existe en français, il signifie "casser le chiffrement" alors que "déchiffrer" signifie "utiliser le chiffre pour obtenir le contenu".
http://fr.wikipedia.org/wiki/Chiffre_(cryptologie)

L'auteur de CRYPTconsol prouve là qu'il s'est mieux documenté sur ce domaine... mais il utilise quand même "crypter" par ci par là.

PPS: tout ce que j'arrive à entr'apercevoir là, c'est que vous êtes tous deux de mauvais programmeurs.