Débutant - Utilisation d'une clé aléatoire pour un cryptage-décryptage

**Goozisan** · 20/10/2006, 22h01

Bonjour,

Je suis étudiante en C++ et j'effectue un projet de cryptage-décryptage avec clé aléatoire de 2 à 5 chiffres.

Mon problème réside dans le code suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void cryptProcess(char t[], int n[])
{
 
cout << "\n\nEcrire le message que vous souhaitez crypter: \n";
cin >> cryptText;
 
for (int i=0, j=1; t[i] != '\0'; j++, i++)
{
 
		t[i]= t[i] + n[j];
 
}

J'arrive bien à crypter les premières lettres correspondant à la longueur de la clé (2 à 5) mais le reste des lettres restent décodées...

Je ne comprends pas pourquoi...

En gros voilà ce que doit donner mon code:

Exemple avec 3 chiffres aléatoires donnés par l'ordi selon la longueur choisie (8, 1, 2)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
FRANCE (mot à crypter)
 
Codage: F+8, R+1, A+2, N+8, C+1, E+2
 
Mot crypté: NSCVDG

Je n'obtient que NSCNCE...

Je ne dois pas utiliser de pointeur car ce n'est pas un chapitre qu'on a encore étudié.
Merci d'avance pour vos conseils.

Goozisan

-----------
Utilise plutot la balise ( le #) plutot que la balise [COLOR][/COLOR]

**Higestromm** · 20/10/2006, 23h09

Bah dans ton algo, n[j] est eu dela de ta clé... j'imagine que les cases non remplie par ta clé doivent êtres à 0.

Peut etre doit tu utiliser un modulo de la longueur de ta clé à cet endroit

**jobherzt** · 21/10/2006, 00h19

je ne comprends pas bien ton code... tu fais entrer le texte dans cryptText, et tu ne l'utilises pas ensuite... et quel tableau contient la clé ?? tu devrais leur donner des noms plus explicites...

sinon, t ne dois pas faire ton test sur la longueur de la clé, mais sur la longueur du texte. en gros :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
message : message en clair
crypt : message crypté
cle : clé
tailleCle : taille de la clé
tailleMessage :  taille du message
 
j=0
de i=0 a tailleMessage -1
   crypt[i]=message[i]+cle[j]
   j=(j+1) modulo tailleCle
fin

en effet, si le message est plus long que la cle on doit reutiliser celle ci (c'est d'ailleurs ce qui fait la faiblesse de ce cryptage).

**koala01** · 21/10/2006, 07h16

Salut,

Envoyé par jobherzt

je ne comprends pas bien ton code... tu fais entrer le texte dans cryptText, et tu ne l'utilises pas ensuite... et quel tableau contient la clé ?? tu devrais leur donner des noms plus explicites...

sinon, t ne dois pas faire ton test sur la longueur de la clé, mais sur la longueur du texte. en gros :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
message : message en clair
crypt : message crypté
cle : clé
tailleCle : taille de la clé
tailleMessage :  taille du message
 
j=0
de i=0 a tailleMessage -1
   crypt[i]=message[i]+cle[j]
   j=(j+1) modulo tailleCle
fin

en effet, si le message est plus long que la cle on doit reutiliser celle ci.

+1, et la petite précision: si le message est plus petit que la clé (ca peut arriver, malgré tout

) la clé n'a pas à etre entièrement utilisée

**Matthieu Brucher** · 21/10/2006, 09h59

C'est un problème d'algorithme pour commencer.
Est-ce que sur papier tu sais comment ton algo tourne pour que ça marche ?

**Goozisan** · 21/10/2006, 18h04

Un grand merci à tous pour vos réponses

Higestromm >> C'est tout à fait ça, les cases non remplies par ma clé sont à zéro. Et utiliser un modulo de la longueur de la clé pourrait en effet m'aider je n'y avais pas pensé...

jobhertz >> En fait, je n'ai pas publié tout mon code ici. Je réutilise bien cryptText par la suite pour donner le résultat du crytpage. Le tableau qui contient ma clé s'appelle keyCode et est déclaré plus tôt dans le programme dans la fonction suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
void crypt()
{
	cout << "\n\nCREER UN MESSAGE CRYPTE\n";
	cout << "\nVeuillez choisir la longueur de la clef (2-5): ";
 
	cin >> keySize;                
 
	cout << "\n\n";
	switch (keySize)                
	{	                                            
	case 2 : random(keyCode, keySize);              // Random fonction utilisée pour l'aléatoire 
							              // void random (int chiffreAleatoire[], int n)			                    
	            cryptProcess(cryptText,keyCode);
	            break;                                 
 
	case 3 : random(keyCode,keySize);               
	              cryptProcess(cryptText,keyCode);       
                            break;
 
	case 4 : random(keyCode,keySize);               
	              cryptProcess(cryptText,keyCode);       
                            break;
 
	case 5 : random(keyCode,keySize);               
	              cryptProcess(cryptText,keyCode);       
                            break;
 
	default : cin.clear();		                   
			  while (cin.get() != '\n')   
				  continue;
 
			  cout << "\nCette alternative n'existe pas. Merci de reessayer.\n";
			  crypt ();           
	}                              
}

Voici la partie complète pour cryptProcess:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void cryptProcess(char t[], int n[])
{
 
cout << "\n\nEcrire le message que vous souhaitez crypter: \n";
cin >> cryptText;
 
for (int i=0, j=1; t[i] != '\0'; j++, i++)
{
 
		t[i]= t[i] + n[j];
 
}
 
 
cout << "\n\n\n" << "Votre message crypte: \n"; 
cout << cryptText;

Pour la taille du texte, est-ce que string paraît plus approprié? En tout cas, je vais essayer d'adapter mon code à ce que tu as proposé. Je te dirai ce que ça donne

**Goozisan** · 21/10/2006, 18h06

Koala01>>Il est vrai que je n'arrive pas à réutiliser la clé pour les autres lettres si le message est plus long...

Miles>> Peut-être que je devrais revoir mon algo

Voici comme je l'avais écrit:

a.L'utilisateur saisit la longueur souhaitée de la clé (2 à 5 chiffres).
b.Le programme génère une clé aléatoire contenant le nombre de chiffres choisis précédement.
c.L'utilisateur saisi le message à crypter.
d.Le programme crypte le message avec la clé aléatoire fournie et montre le résultat.

Qu'en penses-tu?

**jobherzt** · 21/10/2006, 18h22

penses a utiliser la balise CODE pour afficher ton code. pour utiliser le modulo avec la cle, mon algo ci dessus te donne la reponse..

[edit]

je ne vois pas pourquoi tu fais un swith case alors que les instructions sont les memes a chaque fois. il suffirait de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
if (keySize > 5)
{
   cout << "pas bon" << endl;
}else{
   random(key, keysize)
   crypt...
}

[redit]

A part a, la fonction crypt process est presque jste. je ne vois pas pourquoi tu fais commencer j a 1 (ca devrait etre 0). sinon, il te suffit de remplacer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
j++

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
j=(j+1)%tailleCle

et sans te donner toute la solution, remarque que tu ne touches pas cryptText, donc quand tu l'affiches, il va etre exactement comme a l'entrée.. il semblerait que tu composes la cle avec sa taille.. ou un truc bizzare... je ne comprends pas tout.. il faudrait en fait reprendre un peu a la base...

**Matthieu Brucher** · 21/10/2006, 18h44

Envoyé par Goozisan

Miles>> Peut-être que je devrais revoir mon algo

Voici comme je l'avais écrit:

a.L'utilisateur saisit la longueur souhaitée de la clé (2 à 5 chiffres).
b.Le programme génère une clé aléatoire contenant le nombre de chiffres choisis précédement.
c.L'utilisateur saisi le message à crypter.
d.Le programme crypte le message avec la clé aléatoire fournie et montre le résultat.

Qu'en penses-tu?

Pas assez précis, et ça se voit, tu n'as pas explicité la partie vraiment compliquée de ton algorithme, le point d. Donc ce que tu as écrit comme algo ne sert à rien, il ne résoud pas ton problème.

**Goozisan** · 21/10/2006, 20h21

Recoucou

J'ai changé le switch-case en if-else, c'est vrai que c'est plus simple

Voilà ce que j'ai écrit pour le cryptage:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void cryptProcess()
{
 
cout << "\n\nEcrire le message que vous souhaitez crypter: \n";
cin >> originalText;
int j=0;
for (int i=0; originalText[i] ;i++)
{
		cryptText[i]= originalText[i] + keyCode[j];
		j=(j+1) % keySize;		
}
 
 
cout << "\n\n\n" << "Votre message crypte: \n"; 
cout << cryptText;
}

Le problème c'est qu'il ne prend plus en compte le reste de la clé (keyCode[1]) et qu'il me change de caractère une fois sur deux:

abcd avec clé 1, 3
acce

En tout cas, je vais compléter mon algorhytme

**jobherzt** · 21/10/2006, 20h23

est tu sure que keyCode est construit correctement ? car au lieu de (1,3) il applique (0,1), donc je pense que ta cle est decalée d'un cran vers la droite dans ton tableau.

**Goozisan** · 22/10/2006, 20h22

Je ne pense pas que ça vienne de ma clé, mais je poste tout de même la fonction qui permet de la créer, on ne sait jamais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void random(int chiffreAleatoire[], int size)
{
    srand((unsigned)time(0));        
 
 
    cout << "Le programme a genere la clef suivante: \n\n";
 
    for (int i=1; i<=size; i++)         
    {
        chiffreAleatoire[i] = rand() % 10;     
        cout <<chiffreAleatoire[i] <<  ", ";                                     
    }
 
}

En fait, size correspond à la longueur de la clé choisie par l'utilisateur (entre 2 et 5).

Sinon j'ai retravaillé la dernière partie de mon algo:

c. L'utilisateur saisit le message à crypter.

d. Chaque caractère du message, en partant du premier, se voit attribuer un chiffre de la clé de la manière suivante (ex avec clé de 3 chiffres)

lettre [1] + clé [1], lettre [2] + clé[2], lettre[3] + clé[3]

e. Si longueur du message > longueur clé, chaque caractère suivant, et ce, jusqu'à la fin du mot, se verra attribuer de nouveau la clé de cette façon:

lettre [4] + clé [1], lettre [5] + clé[2], lettre[6] + clé[3] etc...

clé [1] devant de nouveau être appliqué à un caractère à chaque fois que clé [dernier chiffre] a été appliqué au caractère précédent.

**jobherzt** · 22/10/2006, 20h29

eh bien si, ca venait de ta fonction... il faut commencer ta boucle a 0, et mettre un "i<size" au lieu de "i<=size".. en c++ on compte a partir de 0

**Goozisan** · 22/10/2006, 21h13

J'hallucine

!!!!!!!

Je me suis fait c...z pendant des heures et des heures pour un zero et un "="

Le pire c'est que dans les consignes du projet, c'est ce code qui a été donné pour trouver un chiffre aléatoire car on n'avait pas encore vu comment faire...

J'ai fait du copier-coller des consignes à mon code... Etant trop scolaire (mon éternel problème concernant mes études), j'étais persuadée que c'était juste alors je n'ai pas cherché l'erreur ici...

J'aurais pu encore chercher pendant des heures...

Je vais en toucher deux mots à mon prof

Un grand merci pour votre aide en tout cas

**koala01** · 23/10/2006, 14h20

Parti quelques jours, je n'ai pas lu toutes les réponses, donc, je vous demanderai d'être indulgents si je fais des redites

Tu as trois possibilités si tu regardes les tailles du texte à krypter et de la clé de cryptages:

le texte à crypter est plus long que la clé de cryptage: il faut utiliser plusieurs fois la clé
le texte à crypter est plus petit que la clé de cryptage: une partie de la clé ne sert à rien
le texte à crypter a la meme taile que la clé de cryptage: la clé n'est utilisée (entièrement) qu'une fois

En fait, cette distinction n'est vraiment que purement théorique, et ce qui suit va t'expliquer le pourquoi:

Dans le cas d'un texte a crypter plus petit que la clé de cryptage, (par exemple, une chaine "ou" et une clé de cryptage "azert") tu peux très bien décider de rajouter les 3 caractères de la clé inutilisés

Le texte crypté serait donc d'une taille identique à la clé de cryptage dont les trois caractères, une fois décryptés, auraient une valeur nulle

Dans le cas d'une chaine à crypter plus longue que la clé de cryptage (exemple: la chaine "je suis une chaine plus longue que la clé de cryptage" avec, toujours la clé "azert") les cinq premiers caractères de la chaine seront mis en relation directe avec les cinq caractères de la clé de cryptage, le sixieme caractère de la chaine avec... le premier de la clé, le septieme de la chaine avec le deuxième de la clé etc...

Bref, chaque caractère est mis en relation avec le modulo de la position du caractère par la taille de la clé...

Si la taille de la chaine à crypter n'est pas strictement un multiple de la taille de la clé, pour les derniers caractères, on tombe dans le premier cas expliqué: on n'a qu'à, au pire, rajouter les derniers caractères inutilisés de la clé

Tout cela pour dire que, apres avoir demandé à l'utilisateur d'introduire le texte à crypter et d'avoir généré (ou demandé) la clé de cryptage, une simple boucle pour gérer tous les caractères de la chaine et un test suffisent à notre bonheur.

exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
//chaine: std::string contenant la chaine à crypter
//cle: std::string contenant la clé de cryptage
//commençons par récupérer les tailles de nos deux chaines
int taillechaine=chaine.length();
int taillecle=cle.length();
//cette boucle va parcourrir toute la chaine à crypter
for(int i=0;i<taillechaine;i++)
{
    //récupération des caractères;
    char &carchaine=chaine[i];
    //pour la clé, il faut utiliser le modulo
    char &carcle=cle[i%taillecle];
    //addition de carcle à carchaine;
    carchaine+=carcle;
}
if(taillechaine%taillecle!=0)
{
   chaine+=cle.substr((taillechaine%taillecle));
}
// affichage de confirmation
std::cout<<" la chaine d'origine avait "<<taillechaine<<" caracteres"<<std::endl
         <<"la chaine cryptee en fait "<<chaine.leng()<<" et vaut "<<std::endl
         <<chaine;

Pour le décodage, une boucle et la suppression des caractères '\0' surnuméraires suffiront à notre bonheur;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
//chaine: std::string contenant la chaine à crypter
//cle: std::string contenant la clé de cryptage
//commençons par récupérer les tailles de nos deux chaines
int taillechaine=chaine.length();
int taillecle=cle.length();
for(int i=0;i<taillechaine;i++)
{
    //récupération des caractères;
    char &carchaine=chaine[i];
    //pour la clé, il faut utiliser le modulo
    char &carcle=cle[i%taillecle];
    //addition de carcle à carchaine;
    carchaine-=carcle;
}
//récupération de la taille d'origine
chaine=chaine.substr(0,chaine.find_first_of('\0'));
// affichage de confirmation
std::cout<<"la chaine faisait "<<taillechaine<<" caracteres"<<std::endl
         <<"la chaine decryptee en fait "<<chaine.length()<<" et vaut"<<std::endl
         <<chaine<<std::endl;

NOTA: Nous aurions très bien pu nous passer des valriables taillechaine et taillecle, mais, cela nous aurait obligé à recourrir systématiquement à chaine.length() et à cle.length()...

Sans avoir fait de tests, je subodore que cela aurait pu nuire aux performances

**loufoque** · 23/10/2006, 15h01

Je suis étudiante en C++

Ouahou une fille

(Veuillez pardonner mon égarement, mais la surprise a été trop forte)

**Goozisan** · 23/10/2006, 15h20

loufoque>> Et oui, il y a des filles qui s'intéressent à la programmation

koala01 >> Merci beaucoup pour tes explications, ça m'aide beaucoup à comprendre d'où venait mes erreurs et à améliorer mes futurs programmes du genre

**koala01** · 24/10/2006, 01h45

Envoyé par Goozisan

loufoque>> Et oui, il y a des filles qui s'intéressent à la programmation

koala01 >> Merci beaucoup pour tes explications, ça m'aide beaucoup à comprendre d'où venait mes erreurs et à améliorer mes futurs programmes du genre

Mais de rien...

Ceci dit, et parce que je suis tombé sur un sujet par hasard, je t'ai proposé une solution basée sur l'addition et la soustraction de valeur pour le cryptage...

Mais tu peux aussi utiliser n'importe quelle méthode dont tu puisse déterminer avec précision la méthode inverse pour le décryptage (les méthodes basées sur les multiplications/divisions sont cependant à éviter, car généralement "non réversibles"

)...

Ainsi, tu pourrais tres bien aussi utiliser la comparaison XOR entre le caractère à crypter et le caractère correspondant de la clé... Mais sans modification de la taille de la chaine...

Cela prendrait, pour le cryptage, une forme ressemblant à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
//chaine: std::string contenant la chaine à crypter
//cle: std::string contenant la clé de cryptage
//commençons par récupérer les tailles de nos deux chaines
int taillechaine=chaine.length();
int taillecle=cle.length();
//cette boucle va parcourrir toute la chaine à crypter
for(int i=0;i<taillechaine;i++)
{
    //récupération des caractères;
    char &carchaine=chaine[i];
    //pour la clé, il faut utiliser le modulo
    char &carcle=cle[i%taillecle];
    //addition de carcle à carchaine;
    carchaine^=carcle;
}
//affichage du résultat (qui risque de te surpendre)
std::cout<<chaine<<std::endl;

Et, pour le décryptage, ben, c'est exactement le meme

(si a XOR b=c, alors c XOR b= a et c XOR a=b

)

N'oublie pas non plus que, plus la clé est longue (et, idéalement, composée de lettres (majuscules ET minuscules) et de chiffres), plus le décryptage sans connaitre la clé et/ou l'algorithme utilisé sera problématique pour une personne mal intentionnée

Débutant - Utilisation d'une clé aléatoire pour un cryptage-décryptage

C++

Discussions similaires

Partager

Partager