Cryptage/décryptage d'un texte par rotation des caractères alphabétiques.

Soyez le premier à donner votre avis sur cette source.

Vue 13 134 fois - Téléchargée 463 fois

Description

Cryptage/Décryptage d'un texte par rotation des caractères alphabétiques.Il faut tapper le texte ou faire copier coller et le prog vous affiche votre texte crypté.
Le décryptage se base sur le nombre d'occurence de la lettre 'e' (lettre la plus fréquente de l'alphabet).

Source / Exemple :

#include <iostream.h>
#include <ctype.h>

using namespace std;
const int MAX=1000;

int remplir(char tab[MAX]);
void compteLettres(char tab[MAX],int nbCar,int freq[26]);
char lettreLaPlusFrequente (int freq[26]);
void cryptage(char tab[MAX],int nbCar,int k);
void decryptage(char tab[MAX],int nbCar,char carFreq);
void affichage(char tableau[MAX],int nbVal);

int remplir(char tab[MAX]) 
{   
	// Procédure qui saisit le texte à crypter ou décrypter //
    // place les caractères dans le tableau et retourne leur nombre //

	char car;
	int i=-1;
	cout<<"Veuillez entrer votre texte. ('$' pour arreter)"<<endl;
	cout<<"***********************************************"<<endl;
	cout<<"<<"<<endl;
    	do  {
   		    i++;
		    cin.get(tab[i]);
        	}
    	while((tab[i]!='$')&&(i<=MAX-2));
	cout<<">>"<<endl;
	if (tab[i]=='$') i--;
	return(i+1);
}


void compteLettres(char tab[MAX],int nbCar,int freq[26])
{
        // Procédure qui compte le nombre de lettres //

	int i,numLettre;
	for(i=0;i<=nbCar;i++)
		{
		numLettre=(tolower(tab[i]))-97;
		freq[numLettre]++;
		}
}

char lettreLaPlusFrequente (int freq[26]) {
        // Fonction qui trouve la lettre la plus fréquente,  //
        // retiens sa position dans l'alphabet //
        // et met 0 dans le tableau à l'adresse de ce caractère pour ne pas
        // le réutiliser si on tente plusieurs décryptages //
	int i,frequente=-1,position=-1;
	char car;
	for(i=0;i<=25;i++) 
		{
		if (freq[i]>frequente)
			{
			frequente=freq[i];
			position=i;
			}
		}	
	car=position+97;
    freq[position]=0;
	return(car);
}

void cryptage(char tab[MAX],int nbCar,int k) {
     // Procédure qui crypte chaque caractère en fonction  //
     // de la clé entrée par l'utilisateur                //

	int i;
    	k=k%(26);        // remet la clé dans l'intervalle [-26 , 26] //


	for(i=0;i<=nbCar-1;i++) 
	{
        // CODAGE DES LETTRES MINUSCULES PAR LE BIAIS DU CODE ASCII //

        // Si la clé est supérieure à 0 //
		if ((k>0) && ((tab[i]) <=122)   && ((tab[i]) >=97))
			{

		    if   (((tab[i]+k) <=122)   && ((tab[i]+k) >=97))  tab[i]+=k;
                  // si tab[i]+k est dans l'intervalle des minuscules : ajouter k //


            else tab[i]=96+k-122+tab[i];
                  // sinon cela implique que l'on dépasse le caractère 'z' //
                  // à ce moment là on doit  repartir du début de l'alphabet minuscule soit à 96 //
            }

        // Si la clé est inférieure à 0 //
		else if (((tab[i]) <=122)  && ((tab[i]) >=97))	
			{
			if (((tab[i]+k) <=122)   && ((tab[i]+k) >=97))   tab[i]+=k;
			else   tab[i]=122-96+k+tab[i];
            }


		// CODAGE DES LETTRES MAJUSCULES PAR LE BIAIS DU CODE ASCII //
		// Si la clé est supérieure à 0 //
		if ((k>0) && ((tab[i]) <=90)   && ((tab[i]) >=65))
			{
  	        if   (((tab[i]+k) <=90)   && ((tab[i]+k) >=65))  tab[i]+=k;
          	else tab[i]=64+k-90+tab[i];
			}
        // Si la clé est inférieure à 0 //
		else if (((tab[i]) <=90)  && ((tab[i]) >=65))	
			{
			if (((tab[i]+k) <=90)   && ((tab[i]+k) >=65))   tab[i]+=k;
			else   tab[i]=90-64+k+tab[i];
			}
	}
}



void decryptage(char tab[MAX],int nbCar,char carFreq)
{
     // Fonction qui décrypte chaque caractère en fonction  de la clé trouvée //


	int k,i;
	k=carFreq-'e';

	for(i=0;i<=nbCar-1;i++) 
		{
            // DECODAGE DES LETTRES MINUSCULES PAR LE BIAIS DU CODE ASCII //

            // Si la clé est supérieure à 0 //
            if ((k>0) && ((tab[i]) <=122)   && ((tab[i]) >=97))
				    {
			     	if   (((tab[i]-k) <=122)   && ((tab[i]-k) >=97))  tab[i]-=k;
                              // si tab[i]-k est dans l'intervalle des minuscules : soustraire k //

                    else tab[i]=-96-k+122+tab[i];
                              // sinon cela implique que l'on dépasse le caractère 'a'   //
                              // à ce moment là on doit  repartir de la fin de l'alphabet//
			      //minuscule soit à 122                                     //
                    }

            // Si la clé est inférieure à 0 //
			else if ( (k<0) && ((tab[i]) <=122)  && ((tab[i]) >=97))	
				    {
				    if (((tab[i]+k) <=122)   && ((tab[i]+k) >=97))   tab[i]+=k;
				    else tab[i]=122-96+k+tab[i];
				    }
		

            // DECODAGE DES LETTRES MAJUSCULES PAR LE BIAIS DU CODE ASCII //

            // Si la clé est supérieure à 0 //
			if ((k>0) && ((tab[i]) <=90)   && ((tab[i]) >=65))
				{
		     		if   (((tab[i]-k) <=90)   && ((tab[i]-k) >=65))  tab[i]-=k;
				else tab[i]=-65-k+91+tab[i];
				}
            // Si la clé est inférieure à 0 //
			else if ( (k<0) && ((tab[i]) <=90)  && ((tab[i]) >=65))	
				{
				if (((tab[i]+k) <=90)   && ((tab[i]+k) >=65))   tab[i]+=k;
				else tab[i]=91-65+k+tab[i];
				}

		}
}


void affichage(char tableau[MAX],int nbVal)      // Procédure d'affichage de tableaux //
{
	for(int i=0;i<=nbVal-1;i++) cout<<tableau[i];
	cout<<endl;
}





void main()		// Fonction principale // 
{ 	

	char carFreq;
	int freq[26]={0};
	char tab[MAX];
	int i,nbCar,k,rep,choix,cpt=0;
		
	cout<<endl;
	cout<<"       ****************************"<<endl;
	cout<<"       *  Mini-projet de C++ No2  *"<<endl;
	cout<<"       *                          *"<<endl;
	cout<<"       *       Programme de       *"<<endl;
	cout<<"       *    cryptage/decryptage   *"<<endl;
	cout<<"       *                          *"<<endl;
	cout<<"       *    Benzekri Sebastien    *"<<endl;
	cout<<"       *   Lanouguere  Baptiste   *"<<endl;
	cout<<"       ****************************"<<endl<<endl;
		

	nbCar=remplir(tab);    // Appelle la fonction "remplir" pour saisir le texte//

	cout<<endl;
	cout<<"Vous avez rentre les "<<nbCar<<" caracteres suivants :"<<endl;
	cout<<"*********************************************"<<endl;
    affichage(tab,nbCar);                       // Affichage du texte entré //

	cout<<endl<<"Voulez vous decoder[1] ou coder[2] ? "<<endl;
    cout<<"************************************"<<endl;
    do {
	cout<<">> ";              // Choix de l'utilisateur : cryptage ou décryptage //
	cin>>rep;
	}
	while(rep!=1 && rep!=2);
    cout<<endl<<endl<<endl;
	
	// PARTIE DECODAGE //
	if (rep==1)
	   {
    	compteLettres(tab,nbCar-1,freq);   // Procésure qui compte le nombre de lettres //
    		do
                {
                carFreq=lettreLaPlusFrequente(freq); //Appelle la fonction "lettreLaPlusFrequente"//

                cout<<endl<<endl;
                cout<<"Le caractere le plus utilise est : "<<carFreq<<endl;

                decryptage(tab,nbCar,carFreq);     // Appelle la procédure de décryptage //

                cpt++;
                cout<<endl<<"Tentative de decryptage no "<<cpt<<" sur "<<nbCar<<" :"<<endl;
                cout<<"**************************************"<<endl;

                affichage(tab,nbCar);           // Affichage du texte décrypté //

                cout<<endl<<"Voulez-vous retenter ([1]=oui [2]=non) ?"<<endl<<">> ";
                cin>>choix;                     // Demande si l'utilisateur est satisafait et //
                                                // continue le cas échéant //
                        }
                while(choix!=2 && cpt<nbCar);
             cout<<endl<<endl;
             if(nbCar==cpt) cout<<"Desole, le nombre de tentatives maximum est depasse."<<endl;
             else if (choix==2) cout<<"Vous avez mis fin au processus"<<endl;
      	     cout<<"*** Decryptage termine ***"<<endl<<endl;
      
      }
      
      
      

     
     	// PARTIE CODAGE //
     else
	    {
      	cout<<endl<<endl;
	    cout<<"Saisissez le coefficient de cryptage :"<<endl;
	    cout<<"**************************************"<<endl<<">> ";
	    cin>>k;                                   // Saisie du coefficient de cryptage //

     	cryptage(tab,nbCar,k);                    // Appelle la procédure de cryptage //
	
     	cout<<endl;
     	cout<<"Voici votre texte crypte :"<<endl;
     	cout<<"**************************"<<endl;
     	affichage(tab,nbCar);                     // Affichage du texte décrypté //
     	cout<<endl;
	    }
}

Conclusion :

Un texte sans la lettre 'e' peut etre décrypté mais au bout d'un certain nombre de fois :-(

MàJ:
le programme se fermait imméditement sans que l'on puisse voir le texte...j'ai rajouté une pause.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
6
Date d'inscription
mardi 31 décembre 2002
Statut
Membre
Dernière intervention
13 décembre 2004

oulala ça c du cryptage avec un coefficient de cryptage de 2 en plus , huuumm je trouve ça très legé surtout pour un programme qui fait 10 km de long. Un simple décalage de lettre est évident rien qu'a l'oeil nu par exemple le www.cppfrance.com une fois crypté donne yyy.errhtcpeg.eqo <- ça si c pas une adresse internet ...
les caractères spéciaux ne sont meme pas cryptés et le fameux coefficient de cryptage est tous simplement symbolique puisque le fait de mettre 1 ou 20 n'augmente pas la difficulté de décryptage.....
Je n'y connait pas grand chose en crypto mais je suis désolé ça va pas chercher loin ton algo...

Rien que ce petit bou de machin est déjà plus compliqué que ton truc :

#include <string.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>

int main(int argc, char *argv[])
{
int j;

char c[30];

printf("Texte à crypter (Ctrl + C pour arrete) : ");
scanf("%s", &c);


printf("==========================================================\n");
printf("Cle saisie : %s\n", c);
printf("Cle codee : ");

int table_ascii[30];
char table_code[30];

char * adr ;
char key_code[30];

adr = c ;
j=0;

while (*adr)
{
table_ascii[j]=*adr;
table_code[j]=table_ascii[j] + (j - 5);

printf ("%c", table_code[j]);
j++;
adr++ ;

}

printf("\n TERMINE\n");


return 0;
}


et là ton www.cppfrance.com devient rst,bpqhuesil6lyx .....
Messages postés
3006
Date d'inscription
dimanche 14 avril 2002
Statut
Membre
Dernière intervention
31 décembre 2008

quand on écrit un cryptage, je pense qu'il faut le faire en se disant: je dois pouvoir distribuer le code source (et même une description précise de l'algo) sans mettre en périle l'efficacité du cryptage. C'est le cas pour du vrai cryptage (avec une clef), ce n'est pas le cas pour de l'encodage (basiquement, du cryptage sans clef), c'est le cas du hashage (mais comme par définition le hashage est "one way" (on ne peut pas récupérer à coup sur les données d'origine à partir du hash. exemples: md5, crc32, ...))


ici sauf erreur c'est de l'encodage, donc tout programmeur en la possession de ce code source peut décrypter tout ce qui a été crypté par ce programme, donc faiblesse. je dis ça pour te prévenir de ne pas utiliser cet algo dans un projet sérieux. ceux qui se sont un peu cassé là tête sur les challenges de crypto/stégano sur www.hackquest.de (en allemand et anglais), se sont bien rendus compte qu'en qq heures on peut casser (parfois même à la main!) des données encodées sans informations précises. même pas en brute forçant.

si tu écris un algo de cryptage sérieux, il va te falloir inclure une clef de cryptage qui ait une importance primordiale, de telle sorte que (presque) uniquement du Brute Force puisse en venir à bout (or le brute force, on connaît tous ses limites ;-))


PS: le screenshot, tu as mis celui de ton code de morse ;-)
Messages postés
3011
Date d'inscription
jeudi 26 septembre 2002
Statut
Membre
Dernière intervention
27 novembre 2004
7
c'est bien coder et bien commenté ;) mais je crois pas que cette methode tienne la route(surtout avec un simple coefficient de cryptage % 26), enfin ca doit juste etre une histoire de qq modif...

sinon using namespace std; est reservé aux nouveaux flux

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.