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

Version imprimable

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:

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:

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]

20/10/2006, 23h09
Higestromm

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

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:

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

Salut,
Citation:
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:

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 ;)

21/10/2006, 09h59
Matthieu Brucher

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

Un grand merci à tous pour vos réponses :D :D

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é... :oops:

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:

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:

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 ;)

21/10/2006, 18h06
Goozisan

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?
21/10/2006, 18h22
jobherzt
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:

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:

1 2 j++
par
Code:

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...:aie:
21/10/2006, 18h44
Matthieu Brucher

Citation:

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.

Recoucou :D

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:

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 ;)

21/10/2006, 20h23
jobherzt

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.

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 :P :aie:
Code:

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.

:) :)

22/10/2006, 20h29
jobherzt

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 ;)
22/10/2006, 21h13
Goozisan

J'hallucine 8O 8O !!!!!!!

Je me suis fait c...z pendant des heures et des heures pour un zero et un "=" http://www.animecdz.com/forum/Smileys/animecdz/mur.gif http://www.animecdz.com/forum/Smileys/animecdz/mur.gif

:aie: :aie:

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

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... :aie: Je vais en toucher deux mots à mon prof http://www.animecdz.com/forum/Smiley...ecdz/batte.gif

Un grand merci pour votre aide en tout cas :D :D

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:

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:

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 ;)

23/10/2006, 15h01
loufoque

Citation:

Je suis étudiante en C++

Ouahou une fille

(Veuillez pardonner mon égarement, mais la surprise a été trop forte)
23/10/2006, 15h20
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 :) :)

Citation:

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:

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 ;) :P)

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 ;)