Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

CODE DE CESAR (CHIFFRE/DÉCHIFFRE) EN C.


Information sur la source

Description

Chiffre et déchiffre un fichier texte selon le code de César.

Le code source est en C (dur dur).
 

Source

  • // code de cesar
  • #include <stdio.h>
  • #include <stdlib.h>
  • // flush
  • void flush()
  • {
  • while( getchar() != '\n' )
  • continue;
  • }
  • // programme principal
  • int main()
  • {
  • int decalage = 0;
  • char nom_fichier[256];
  • char choix = 'c';
  • // choix
  • printf( "Code de Cesar\n" );
  • printf( "\nSaisir le décalage : " );
  • scanf( "%d", &decalage );
  • flush();
  • printf( "\nSaisir le nom du fichier : " );
  • scanf( "%s", nom_fichier );
  • flush();
  • printf( "\nChiffrement [c] ou déchiffrement [d] : " );
  • scanf( "%c", &choix );
  • // synthèse
  • switch( choix )
  • {
  • case 'c' :
  • printf("\nVous avez demandé le chiffrement du fichier %s avec un décalage de %d.\n", nom_fichier, decalage );
  • {
  • int index;
  • int taille_fichier = 0;
  • FILE * fichier_avant = NULL;
  • FILE * fichier_apres = NULL;
  • int taille_memoire_tamon = 1024;
  • char * memoire_tampon = NULL;
  • // allocation
  • memoire_tampon = (char*)malloc(taille_memoire_tamon);
  • // mise en mémoire tampon
  • fichier_avant = fopen( nom_fichier, "r" );
  • taille_fichier = fread( memoire_tampon, 1, taille_memoire_tamon, fichier_avant );
  • fclose( fichier_avant );
  • // chiffrement dans le mémoire tampon
  • for( index = 0; index != taille_fichier; ++index )
  • {
  • // chiffrement des majuscules
  • if( memoire_tampon[ index ] >=65 && memoire_tampon[ index ] < 91 )
  • memoire_tampon[ index ] = ( ( memoire_tampon[ index ] - 65 ) + decalage ) % 26 + 65;
  • // chiffrement des minuscules
  • if( memoire_tampon[ index ] >=97 && memoire_tampon[ index ] < 123 )
  • memoire_tampon[ index ] = ( ( memoire_tampon[ index ] - 97 ) + decalage ) % 26 + 97;
  • }
  • // mise a jour du fichier
  • fichier_apres = fopen( nom_fichier, "w" );
  • fwrite( memoire_tampon, 1, taille_fichier, fichier_apres );
  • fclose( fichier_apres );
  • // desallocation
  • free( memoire_tampon);
  • }
  • return 0;
  • case 'd' :
  • printf("\nVous avez demandé le déchiffrement du fichier %s avec un décalage de %d.\n", nom_fichier, decalage );
  • {
  • int index;
  • int taille_fichier = 0;
  • FILE * fichier_avant = NULL;
  • FILE * fichier_apres = NULL;
  • int taille_memoire_tamon = 1024;
  • char * memoire_tampon = NULL;
  • // allocation
  • memoire_tampon = (char*)malloc(taille_memoire_tamon);
  • // mise en mémoire tampon
  • fichier_avant = fopen( nom_fichier, "r" );
  • taille_fichier = fread( memoire_tampon, 1, taille_memoire_tamon, fichier_avant );
  • fclose( fichier_avant );
  • // déchiffrement dans le mémoire tampon
  • for( index = 0; index != taille_fichier; ++index )
  • {
  • // déchiffrement des majuscules
  • if( memoire_tampon[ index ] >=65 && memoire_tampon[ index ] < 91 )
  • memoire_tampon[ index ] = ( ( memoire_tampon[ index ] - 65 ) - decalage ) % 26 + 65;
  • // déchiffrement des minuscules
  • if( memoire_tampon[ index ] >=97 && memoire_tampon[ index ] < 123 )
  • memoire_tampon[ index ] = ( ( memoire_tampon[ index ] - 97 ) - decalage ) % 26 + 97;
  • }
  • // mise a jour du fichier
  • fichier_apres = fopen( nom_fichier, "w" );
  • fwrite( memoire_tampon, 1, taille_fichier, fichier_apres );
  • fclose( fichier_apres );
  • // desallocation
  • free( memoire_tampon);
  • }
  • return 0;
  • default:
  • return -1;
  • }
  • }
// code de cesar

#include <stdio.h>
#include <stdlib.h>


// flush
void flush()
{
	while( getchar() != '\n' )
		continue;
}

// programme principal
int main()
{
	int decalage = 0;
	char nom_fichier[256];
	char choix = 'c';
	// choix
	printf( "Code de Cesar\n" );
	printf( "\nSaisir le décalage : " );
	scanf( "%d", &decalage );
	flush();
	printf( "\nSaisir le nom du fichier : " );
	scanf( "%s", nom_fichier );
	flush();
	printf( "\nChiffrement [c] ou déchiffrement [d] : " );
	scanf( "%c", &choix );
	// synthèse
	switch( choix )
	{
	case 'c' :
		printf("\nVous avez demandé le chiffrement du fichier %s avec un décalage de %d.\n", nom_fichier, decalage );
		{
			int index;
			int taille_fichier = 0;
			FILE * fichier_avant = NULL;
			FILE * fichier_apres = NULL;
			int taille_memoire_tamon = 1024;
			char * memoire_tampon = NULL;
			// allocation
			memoire_tampon = (char*)malloc(taille_memoire_tamon);
			// mise en mémoire tampon
			fichier_avant = fopen( nom_fichier, "r" );
			taille_fichier = fread( memoire_tampon, 1, taille_memoire_tamon, fichier_avant );
			fclose( fichier_avant );
			// chiffrement dans le mémoire tampon
			for( index = 0; index != taille_fichier; ++index )
			{
				// chiffrement des majuscules
				if( memoire_tampon[ index ] >=65 && memoire_tampon[ index ] < 91 )
					memoire_tampon[ index ] = ( ( memoire_tampon[ index ] - 65 ) + decalage ) % 26 + 65;
				// chiffrement des minuscules
				if( memoire_tampon[ index ] >=97 && memoire_tampon[ index ] < 123 )
					memoire_tampon[ index ] = ( ( memoire_tampon[ index ] - 97 ) + decalage ) % 26 + 97;
			}
			// mise a jour du fichier
			fichier_apres = fopen( nom_fichier, "w" );
			fwrite( memoire_tampon, 1, taille_fichier, fichier_apres );
			fclose( fichier_apres );
			// desallocation
			free( memoire_tampon);
		}
		return 0;
	case 'd' :
		printf("\nVous avez demandé le déchiffrement du fichier %s avec un décalage de %d.\n", nom_fichier, decalage );
		{
			int index;
			int taille_fichier = 0;
			FILE * fichier_avant = NULL;
			FILE * fichier_apres = NULL;
			int taille_memoire_tamon = 1024;
			char * memoire_tampon = NULL;
			// allocation
			memoire_tampon = (char*)malloc(taille_memoire_tamon);
			// mise en mémoire tampon
			fichier_avant = fopen( nom_fichier, "r" );
			taille_fichier = fread( memoire_tampon, 1, taille_memoire_tamon, fichier_avant );
			fclose( fichier_avant );
			// déchiffrement dans le mémoire tampon
			for( index = 0; index != taille_fichier; ++index )
			{
				// déchiffrement des majuscules
				if( memoire_tampon[ index ] >=65 && memoire_tampon[ index ] < 91 )
					memoire_tampon[ index ] = ( ( memoire_tampon[ index ] - 65 ) - decalage ) % 26 + 65;
				// déchiffrement des minuscules
				if( memoire_tampon[ index ] >=97 && memoire_tampon[ index ] < 123 )
					memoire_tampon[ index ] = ( ( memoire_tampon[ index ] - 97 ) - decalage ) % 26 + 97;
			}
			// mise a jour du fichier
			fichier_apres = fopen( nom_fichier, "w" );
			fwrite( memoire_tampon, 1, taille_fichier, fichier_apres );
			fclose( fichier_apres );
			// desallocation
			free( memoire_tampon);
		}
		return 0;
	default:
		return -1;
	}
}

Conclusion

C'est un premier jet pour répondre rapidement à une demande. Je factoriserai certaines protions de code.
 

Commentaires et avis

signaler à un administrateur
Commentaire de Xs le 05/06/2005 17:09:05

Bonjour,

c'est sympa un petit code sur le cryptage de césar. Suffit qu'on en ait pas assez... Qui se dévoue pour compter le nombre de sources parlant de cryptage affine ??
Le pire, c'est qu'en plus casser ce cryptage est élémentaire...
Cordialement.

signaler à un administrateur
Commentaire de jad_raad le 06/06/2005 00:12:31

j'ai pas compris en fait le principe de chiffrement et de dechiffrement ,tu peux m'expliquer un peu le but de ton code et j'aurais besoin de savoir le syntaxe du fontion malloc() et à koi ca sert et de la fonction flush().
merci

signaler à un administrateur
Commentaire de xterminhate le 06/06/2005 00:20:05

Je t'invite à consulter les liens suivans :
* Le code de César : http://www.bibmath.net/crypto/substi/cesar.php3
* La fonction malloc : http://www.opengroup.org/onlinepubs/009695399/functions/malloc.html

La fonction flush vide le buffer d'entrée standard de manière à enchainer les saisies au clavier correctement.

signaler à un administrateur
Commentaire de jad_raad le 06/06/2005 01:15:18

ok CooL,merci

signaler à un administrateur
Commentaire de dominion le 06/06/2005 17:38:19

Bon, le code est pas trop crade pour ce que j'ai lu (j'ai peut-être laissé passre des erreurs...), mais pourquoi diable coder un CESAR alors qu'il y en a déjà plein et qu'apparament tu connais déjà bien le C ????? Un XOR au moins je sais pas...
Pour info : un César se casse environ en disons 10 minutes, maximum...

signaler à un administrateur
Commentaire de xterminhate le 06/06/2005 17:41:39

Je vous invite à (re)lire la partie "explication finale" pour comprendre le pourquoi de ce manque d'originalité. ;-)

signaler à un administrateur
Commentaire de dominion le 06/06/2005 17:48:32

Ben ça explique rien... Une url et hop c'est gagné...
Je mets pas de note : dur de dire si ce code est mauvais : il fait ce qu'on lui demande, mais bon... c'est César !

signaler à un administrateur
Commentaire de xterminhate le 06/06/2005 18:00:40

Compte-tenu de l'évolution de la cryptographie, le code de César est tres simple à casser.

Pour ceux qui sont joueurs (et qui critiquent bcp César), je vous lance un défit. Faites un programme en pur C qui casse -> automatiquement <- le code de césar (en somme, un programme qui retourne la valeur du décalage de l'alphabet). Ce programme devra fonctionner pour au moins deux langues de votre choix : français et anglais par exemple.

C'est l'histoire de quelques lignes bien pensées, ca devrait être divertissant. ;-)

signaler à un administrateur
Commentaire de dominion le 06/06/2005 18:22:35

Ben, c'est ridicule ! Tu passe la première ligne du fichier césarée 26 fois et l'utilisateur dit laquelle est bonne et c'est bon ! Pourquoi se fatiguer ?

J'ai un défi plus intéressant : faire de même, mais avec un XOR, ou autre substitution quelconque... Là ça devient marrant !

(Et pour les plus mazo, ya toujours Vigenère ;-P)

signaler à un administrateur
Commentaire de xterminhate le 06/06/2005 18:30:37

L'interêt consiste à automatiquer le processus de cryptanalyse. Ce n'est pas plus compliqué de casser un XOR ou un César à partir du moment ou tu sais dire si le texte déchiffré est conhérent. Non ?

signaler à un administrateur
Commentaire de dominion le 06/06/2005 18:39:02

Bien vu, mais bon pour César il suffit de partir du principe que le 'e' en fr ressort le plus souvent (dans le cas de longs textes, s'entend), de touver la lettre qui ressort le plus souvent, puis de simplement calculer le delta(le pas si tu préfère) et bon là c'est gagné...

On peut même demander à l'user si c'est juste (99% des cas : oui), et si cela ne l'est pas, ben il recommence en considérant le deuxième plus présent etc...

Par contre, avec une substitution, il y a beaucoup plus de cas, et l'erreur est vite faite !

Pour casser un cryptage, il faut toujours se trouver derrière, sauf si tu t'amuse à créer un dico et à regarder si la majorité des mots dans le texte cassé est dans ton dico, si c'est le cas c'est bon... Mais c'est long et un peu inutile, il faut avouer...

signaler à un administrateur
Commentaire de mythic_kruger le 02/07/2005 19:34:35

Le code est très redondant (chiffrer/déchiffrer) néanmoins c'est un sujet toujours d'actualité et source de bon sens.
Casser un XOR ou un César à partir du moment ou on sait dire si le texte déchiffré est cohérent, c'est pas plus compliqué mais c'est plus long! lol
Le stade au dessus du César est l' utilisation d'une clé de cryptage et ceci a pour effet sur le code crypté de ne pas présenter de récurrence de caractère. En effet, dans le cas du césar, le A devenant toujours D est identifié par cette corelation définie par le décalage de 3. Or, dans le cas du codage avec une clé, le code ASCII du caractère à convertir n'est pas décalé de 3 mais de la valeur de décalage issue du caractère de même index de la clé. Coder AA en César donne DD. avec une clé de cryptage, AA deviendrait ùp par exemple... D'autant plus puissant et long à casser que la clé est longue. La règle n°1 étant de développer sur une machine non connectée au réseau (sans mail) quel que soit l'algorythme de cryptage.

signaler à un administrateur
Commentaire de xterminhate le 02/07/2005 21:16:55

...et l'algorithme cryptographique est encore renforcé en utilisant un mode "chainé" (genre CBC,...) en rendant chaque bloc cryptographique dépendant.

Ajouter un commentaire



Nos sponsors

Sondage...

CalendriCode

Juillet 2009
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Comparez les prix Nouvelle version

Photothèque Nouveau !



Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 0,296 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.