Contenu | Rechercher | Menus

Annonce

Si vous rencontrez des soucis à rester connecté sur le forum (ou si vous avez perdu votre mot de passe) déconnectez-vous et reconnectez-vous depuis cette page, en cochant la case "Me connecter automatiquement lors de mes prochaines visites".

#1 Le 20/01/2013, à 22:58

Destroyers

[C++] Sondage: programmes de chiffrement amateur. [Resolu]

Bonjour linuxiens.

Avec un ami, nous nous sommes lancé un petit défi: réaliser un logiciel de cryptage en console chacun.
Ils sont maintenant à la toute fin de leur phase Bêta.

Nous faisons appel à vous pour nous aider a définir lequel de ces deux programmes est le meilleur (ergonomie, sécurité, performances...).
voici les liens pour vous procurer ces deux programmes:
CRYPTconsol
Encryptor

Demandez nos sources si cela peut vous intéresser wink

Merci beaucoup.

Dernière modification par Destroyers (Le 21/01/2013, à 13:37)


-Asus X53S -core i7-2630QM 2GHz (booster 800MHz)
-NVidia GT540M 2Go technologie Optimus
-RAM 4Go -disque dur 750Go 5400 RPM
-Dual boot (linux/windows7)

Hors ligne

#2 Le 21/01/2013, à 00:00

Maisondouf

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

Excuses moi mais je ne suis pas arrivé à les télécharger, mon anti-pub a tout bloqué.
Essayes de les héberger ailleurs.


ASUS M5A88-v EVO avec AMD FX(tm)-8120 Eight-Core Processor,  OS principal Precise 12.04.1 LTS 63bits½
Bricoleur, menteur, inculte, inadapté social et mythomane, enfin d'après certains....
"the secret of my form is summed up in two words, no sport" (Winston Churchill)

Hors ligne

#3 Le 21/01/2013, à 00:11

Stalker2106

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

J'ai ré-hébergé les fichiers pour éviter les soucis :
CRYPTconsol
Encryptor

Merci d'avance !

Dernière modification par Stalker2106 (Le 21/01/2013, à 00:20)

Hors ligne

#4 Le 21/01/2013, à 00:58

Maisondouf

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

Alors première impression, vous avez tous les deux gagné le premier Gérard du scripte imbuvable...
Sérieusement, je suis sûr que vous êtes tous les deux des "tronchus" capable de pondre des DES ou autres algo bien chiadés au petit déjeuner, mais il va falloir vous faire des tartines d'ergonomie pour tremper dans votre bol.
Potassez dans un premier temps la doc de "zenity", c'est un petit interface utilisateur qui sera très facile à intégrer dans vos scriptes et va rendre les choses plus accueillantes.
Sinon, coté cryptage, rien à redire wink

Dernière modification par Maisondouf (Le 21/01/2013, à 00:59)


ASUS M5A88-v EVO avec AMD FX(tm)-8120 Eight-Core Processor,  OS principal Precise 12.04.1 LTS 63bits½
Bricoleur, menteur, inculte, inadapté social et mythomane, enfin d'après certains....
"the secret of my form is summed up in two words, no sport" (Winston Churchill)

Hors ligne

#5 Le 21/01/2013, à 02:08

Stalker2106

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

Oui effectivement l'interface est assez austère, on est dans le terminal cela ne fait aucun doute.
D'un autre coté, ce projet avait pour unique but l'approfondissement des conaissances des bases en C++, dans Encryptor par exemple, la POO est inexistante.
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.
Coté cryptage il est évident que CRYPTconsol possède une sécurité supplémentaire a son concurrent direct, mais les deux réalisent un cryptage sans défaut,
même si celui ci peut s'averer fastidieux a réaliser ( notamment dans CRYPTconsol )

Vous remarquerez bien evidemment que je suis l'auteur d'Encryptor wink
Merci de votre commentaire.

Hors ligne

#6 Le 21/01/2013, à 02:33

Maisondouf

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

Zenity est très utilisé pour améliorer les scriptes type shell linux, le GTK est plus facile à appréhender à partit d'un langage évolué.
Mais si ce n'était qu'un challenge entre potes, je ne me permettrais pas de vous départager, je n'ai pas la prétention d'en avoir le rôle.


ASUS M5A88-v EVO avec AMD FX(tm)-8120 Eight-Core Processor,  OS principal Precise 12.04.1 LTS 63bits½
Bricoleur, menteur, inculte, inadapté social et mythomane, enfin d'après certains....
"the secret of my form is summed up in two words, no sport" (Winston Churchill)

Hors ligne

#7 Le 21/01/2013, à 09:06

tiramiseb

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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.

Dernière modification par tiramiseb (Le 21/01/2013, à 09:11)


Sébastien Maccagnoni-Munch - administrateur Linux depuis le XXème siècle
Consultant informatique indépendant - http://www.smm-informatique.fr
Geek et tout plein d'autres choses - http://www.tiramiseb.fr

En ligne

#8 Le 21/01/2013, à 11:05

Destroyers

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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

Dernière modification par Destroyers (Le 21/01/2013, à 11:07)


-Asus X53S -core i7-2630QM 2GHz (booster 800MHz)
-NVidia GT540M 2Go technologie Optimus
-RAM 4Go -disque dur 750Go 5400 RPM
-Dual boot (linux/windows7)

Hors ligne

#9 Le 21/01/2013, à 11:31

tiramiseb

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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 smile


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


Sébastien Maccagnoni-Munch - administrateur Linux depuis le XXème siècle
Consultant informatique indépendant - http://www.smm-informatique.fr
Geek et tout plein d'autres choses - http://www.tiramiseb.fr

En ligne

#10 Le 21/01/2013, à 11:47

Destroyers

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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<std::streamsize>::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 (" <<txt.get_taille()<<" caractères) et chiffré)\n";
				}
				else
				{
					std::cout<<" (un texte est actuellement présent (" <<txt.get_taille()<<" caractères) et non chiffré)\n";
				}
			}
			else
			{
				std::cout<<" (aucun actuellement)\n";
			}

                std::cout<<"tapez 2 pour voir votre texte,\n";
                std::cout<<"tapez 3 pour enregistrer votre texte dans un fichier,\n";
                std::cout<<"tapez 4 pour importer votre texte depuis un fichier,\n";
                std::cout<<"tapez 5 pour afficher l'historique de développement,\n";
                std::cout<<"tapez 6 pour quitter votre logiciel de cryptage CRYPTconsol.\n \n";

                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<std::streamsize>::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<std::streamsize>::max(), '\n');
		}
	}
	else
	{
		ecrire();
	}
}


void code::ecrire()
//écrire un texte
{
	std::cout<<"Entrez votre texte: \n";
    	std::cin.ignore(std::numeric_limits<std::streamsize>::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<std::streamsize>::max(), '\n');

	}
	else
	{
	    	std::cout<<"Votre texte est prêt.\n";
		ecrit=true;
		taille=phrase.size()-1;
	    	std::cin.ignore(std::numeric_limits<std::streamsize>::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<<phrase<<'\n';
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
    else if(ecrit==false)
    {
        	std::cout<<"Erreur: aucun texte n'est présent.\n";
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
		std::cin.ignore(std::numeric_limits<std::streamsize>::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<choix.size();i++)
		{
			tolower(choix[i]); 	//on met les caracteres en minuscules pour que la condition les reconnaisse
		}	
		if(choix=="oui"||choix=="yes"||choix=="o"||choix=="y")
		{
			entree_valide=true;
			std::cout<<"Vous voulez supprimer votre texte: ... \n";
 			if(ecrit==true)
   		    	{
				phrase="";
				ecrit=false;
				crypte=false;
				taille=0;
     		    		std::cout<<"Votre texte a bien été supprimé.\n";
				std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
				std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
   	  	    	}
   	 	    	else if(ecrit==false)
   	 	    	{
        			std::cout<<"Erreur: aucun texte n'est présent.\n";
				std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
				std::cin.ignore(std::numeric_limits<std::streamsize>::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<std::streamsize>::max(), '\n');
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
		}
		else
		{
			std::cout<<"Erreur: choix inexistant.\n";
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
			std::cin.ignore(std::numeric_limits<std::streamsize>::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<std::streamsize>::max(), '\n');
			   	std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
			   	break;

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

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

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

			case 4:
			    	choix4(phrase);
			    	crypte=true;
			    	std::cout<<"Votre texte a bien été chiffré.\n";
			   	std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
			    	std::cin.ignore(std::numeric_limits<std::streamsize>::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<phrase.size();i++)
			{
				temporaire+=phrase[i];
			}
			phrase=temporaire;
			phrase+='p';
			taille=phrase.size()-4;
		}
		else if(premier==1)
		{
			std::string temporaire;
			temporaire+='Q';
			for(unsigned int i=0;i<phrase.size();i++)
			{
				temporaire+=phrase[i];
			}
			phrase=temporaire;
			phrase+='p';
			taille=phrase.size()-4;
		}
		else if(premier==2)
		{
			std::string temporaire;
			temporaire+='%';
			for(unsigned int i=0;i<phrase.size();i++)
			{
				temporaire+=phrase[i];
			}
		phrase=temporaire;
		taille=phrase.size()-3;
		}
		else
		{
			taille=phrase.size()-2;
		}
		
	}
	else if(ecrit==true && crypte==true)
	{
		std::cout<<"Impossible de chiffrer votre texte car il est déjà crypté.\n";
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
	}
    	else if(ecrit==false)
    	{
        	std::cout<<"Erreur: aucun texte n'est présent.\n";
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    	}
   	else
    	{
        	std::cout<<"Erreur: une erreur inconue est survenue.\n";
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    		std::cin.ignore(std::numeric_limits<std::streamsize>::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"<<phrase<<"\n\n";
	std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
	std::cin.ignore(std::numeric_limits<std::streamsize>::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<std::streamsize>::max(), '\n');
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
    else if(ecrit==false)
    {
        std::cout<<"Erreur: aucun texte n'est présent.\n";
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
    else
    {
        std::cout<<"Erreur: une erreur inconue est survenue.\n";
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
		std::cin.ignore(std::numeric_limits<std::streamsize>::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<<phrase;
				std::cout<<"Votre fichier a été enregistré avec succès.\n";
				std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
				std::cin.ignore(std::numeric_limits<std::streamsize>::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<std::streamsize>::max(), '\n');
				std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
			}
	    }
	    else if (!ecrit)
	    {
		std::cout<<"Erreur: aucun texte n'est écrit.\n";
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
	    }
	    else
	    {
		std::cout<<"Erreur: une erreur inconue vient de se produire.\n";
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
			std::cin.ignore(std::numeric_limits<std::streamsize>::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<std::streamsize>::max(), '\n');
			std::cin.ignore(std::numeric_limits<std::streamsize>::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<test; i++)
            	{
                	texte+=flux.get();
            	}
                crypte=true;
                ecrit=true;
		taille=size;
                phrase=texte;
                std::cout<<"Votre fichier a été ouvert avec succès et son contenu a été transféré avec succès.\n";
		std::cout<<"Voici le contenu:\n\n"<<phrase<<"\n\n";
		std::cout<<"-"<<taille<<" caractères ont été identifiés.\n";
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
		std::cin.ignore(std::numeric_limits<std::streamsize>::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<std::streamsize>::max(), '\n');
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            }
            else
            {
                std::cout<<"Erreur: une erreur inconnue est survenue lors du transfert des donées.\n";
				std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
				std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            }
        }
        else
        {
			std::cout<<"Erreur: une erreur inconnue vient de se produire.\n";
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
			std::cin.ignore(std::numeric_limits<std::streamsize>::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<std::streamsize>::max(), '\n');
		std::cin.ignore(std::numeric_limits<std::streamsize>::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<std::streamsize>::max(), '\n');
			std::cin.ignore(std::numeric_limits<std::streamsize>::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<size; i++)
		       	{
		       	 	texte+=flux.get();
		  	}
			crypte=false;
		       	ecrit=true;
			taille=size;
            		phrase=texte;
	            	std::cout<<"Votre fichier a été ouvert avec succès et son contenu a été transféré avec succès.\n";
			std::cout<<"Voici le contenu:\n\n"<<phrase<<"\n\n";
			std::cout<<"-"<<taille<<" caractères ont été identifiés.\n";
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
	    	}
        }
        else
        {
			std::cout<<"Erreur: une erreur inconnue vient de se produire.\n";
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
			std::cin.ignore(std::numeric_limits<std::streamsize>::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<std::streamsize>::max(), '\n');
	std::cin.ignore(std::numeric_limits<std::streamsize>::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<std::streamsize>::max(), '\n');
	std::cin.ignore(std::numeric_limits<std::streamsize>::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 (" <<txt.get_taille()<<" caractères) et chiffré)\n";
				}
				else
				{
					std::cout<<" (un texte est actuellement présent (" <<txt.get_taille()<<" caractères) et non chiffré)\n";
				}

			}
			else
			{
				std::cout<<" (aucun actuellement)\n";
			}
			std::cout<<"tapez 2 pour supprimer votre texte,\n";
			std::cout<<"tapez 3 pour chiffrer/déchiffrer votre texte,\n";
			std::cout<<"tapez 4 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<std::streamsize>::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<std::streamsize>::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.size();i++) //on décale toutes les lettres pour que
	{					//le premier caractère soit le type d'encodage.
		temporaire+=a[i];
	}
	a=temporaire;

    for(unsigned int i=1; i<a.size();i++)
    {
	switch(a[i])
	{
		case 'a':
		a[i]='l';
		break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		case '>':
		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.size();i++) //on décale toutes les lettres pour que
	{					//le premier caractère soit le type d'encodage.
		temporaire+=a[i];
	}
	a=temporaire;
    	for(unsigned int i=1; i<a.size();i++)
    	{
		switch(a[i])
		{
        		case 'a':
			a[i]='7';
			break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			case '>':
			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.size();i++) //on décale toutes les lettres pour que
	{					//le premier caractère soit le type d'encodage.
		temporaire+=a[i];
	}
	a=temporaire;
    for(unsigned int i=1; i<a.size();i++)
    {
		switch(a[i])
		{
			case 'a':
			a[i]='v';
			break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			case '/':
			a[i]='l';
			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;
		}

    	}
}


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.size();i++) //on décale toutes les lettres pour que
	{					//le premier caractère soit le type d'encodage.
		temporaire+=a[i];
	}
	a=temporaire;
    for(unsigned int i=1; i<a.size();i++)
    {
		switch(a[i])
		{
			case 'a':
			a[i]='d';
			break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			case '>':
			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.size();i++) //on décale toutes les lettres pour que
	{					//le premier caractère soit le type d'encodage.
		temporaire+=a[i];
	}
	a=temporaire;
    	for(unsigned int i=1; i<a.size();i++)
    	{
		switch(a[i])
		{
			case 'a':
			a[i]='B';
			break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			case '>':
			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.size()-1;i++)
    		{
			switch(a[i])
			{
        			case 'l':
				a[i]='a';
				break;

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

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

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

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

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

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

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

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

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

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

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

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

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

				case '>':
				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.size()-1;i++)
			{
				switch(a[i])
				{
					case '7':
					a[i]='a';
					break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

					case '>':
					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.size()-1;i++)
			{
				switch(a[i])
				{
					case 'v':
					a[i]='a';
					break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

					case '>':
					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.size()-1;i++)
			{
				switch(a[i])
				{
					case 'd':
					a[i]='a';
					break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

					case '>':
					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.size()-1;i++)
			{
				switch(a[i])
				{
					case 'B':
					a[i]='a';
					break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

					case '>':
					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<iostream>
#include<string>
#include<limits>
#include<sstream>
#include<ctime>
#include<cstdlib>
#include<fstream>
#include<cctype>

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

#endif
//header.cpp

#include"header.h"




Sources de Encryptor:

//mains.cpp

#include <iostream>
#include <string>
#include <fstream>
#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 <iostream>
#include <string>
#include <fstream>
#include <limits>
#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<std::streamsize>::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<std::streamsize>::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 <iostream>
#include <string>
#include <fstream>
#include <sstream>
#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 <iostream>
#include <string>
#include <fstream>
#include <limits>
#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<std::streamsize>::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;
}

Dernière modification par Destroyers (Le 21/01/2013, à 11:52)


-Asus X53S -core i7-2630QM 2GHz (booster 800MHz)
-NVidia GT540M 2Go technologie Optimus
-RAM 4Go -disque dur 750Go 5400 RPM
-Dual boot (linux/windows7)

Hors ligne

#11 Le 21/01/2013, à 11:55

tiramiseb

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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

Dernière modification par tiramiseb (Le 21/01/2013, à 11:55)


Sébastien Maccagnoni-Munch - administrateur Linux depuis le XXème siècle
Consultant informatique indépendant - http://www.smm-informatique.fr
Geek et tout plein d'autres choses - http://www.tiramiseb.fr

En ligne

#12 Le 21/01/2013, à 12:07

Destroyers

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

Bref: on est nul


-Asus X53S -core i7-2630QM 2GHz (booster 800MHz)
-NVidia GT540M 2Go technologie Optimus
-RAM 4Go -disque dur 750Go 5400 RPM
-Dual boot (linux/windows7)

Hors ligne

#13 Le 21/01/2013, à 12:09

tiramiseb

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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 smile


Sébastien Maccagnoni-Munch - administrateur Linux depuis le XXème siècle
Consultant informatique indépendant - http://www.smm-informatique.fr
Geek et tout plein d'autres choses - http://www.tiramiseb.fr

En ligne

#14 Le 21/01/2013, à 12:15

sogyam

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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à roll

Dernière modification par sogyam (Le 21/01/2013, à 12:16)

Hors ligne

#15 Le 21/01/2013, à 12:16

Stalker2106

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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

Hors ligne

#16 Le 21/01/2013, à 12:17

tiramiseb

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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


Sébastien Maccagnoni-Munch - administrateur Linux depuis le XXème siècle
Consultant informatique indépendant - http://www.smm-informatique.fr
Geek et tout plein d'autres choses - http://www.tiramiseb.fr

En ligne

#17 Le 21/01/2013, à 12:19

tiramiseb

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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 big_smile


Sébastien Maccagnoni-Munch - administrateur Linux depuis le XXème siècle
Consultant informatique indépendant - http://www.smm-informatique.fr
Geek et tout plein d'autres choses - http://www.tiramiseb.fr

En ligne

#18 Le 21/01/2013, à 12:27

Stalker2106

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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

Hors ligne

#19 Le 21/01/2013, à 12:42

Destroyers

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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


-Asus X53S -core i7-2630QM 2GHz (booster 800MHz)
-NVidia GT540M 2Go technologie Optimus
-RAM 4Go -disque dur 750Go 5400 RPM
-Dual boot (linux/windows7)

Hors ligne

#20 Le 21/01/2013, à 12:43

tiramiseb

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

Et t'as testé avec "titi" ? lol


Sébastien Maccagnoni-Munch - administrateur Linux depuis le XXème siècle
Consultant informatique indépendant - http://www.smm-informatique.fr
Geek et tout plein d'autres choses - http://www.tiramiseb.fr

En ligne

#21 Le 21/01/2013, à 12:52

Destroyers

Re : [C++] Sondage: programmes de chiffrement amateur. [Resolu]

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


-Asus X53S -core i7-2630QM 2GHz (booster 800MHz)
-NVidia GT540M 2Go technologie Optimus
-RAM 4Go -disque dur 750Go 5400 RPM
-Dual boot (linux/windows7)

Hors ligne

Haut de page ↑