begin process at 2012 02 08 10:15:20
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Sécurité & Cryptage

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

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.


 Sources du même auteur

Source avec Zip CLASSE INTERPRETEUR DE COMMANDES
Source avec Zip MINXL (MINIMALIST XML LIBRARY) : GÉNÉRATEUR/ANALYSEUR/TRAITE...
Source avec une capture OPTIMISATION DES CALLBACKS C++ RÉSOLUS À LA COMPILATION.
Source avec Zip [WIN32 & LINUX] THREADS C++
Source avec Zip SERVEUR HTTP 1.1 SIMPLE V2.XX (WINDOWS & GNU/LINUX COMPATIBL...

 Sources de la même categorie

PROJET DE CRYPTOGRAPHIE: RSA À JEU REDUIT D'INSTRUCTION par samatarahmed
Source avec Zip Source avec une capture CRYPTOSYSTÈME ELGAMAL LIBRAIRIE GMP par louelh95
Source avec Zip Source .NET (Dotnet) NOUVEL ALGORITHME D'ENCRYPTION-DÉSENCRYPTION DYNAMIQUE (INFA... par vletktol
Source avec Zip A2DCRYPT - CRYPTAGE 2048 BITS par darkor
Source avec Zip Source avec une capture CRYPTEUR-DÉCRYPTEUR-IP par antho974

Commentaires et avis

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.

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

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.

Commentaire de jad_raad le 06/06/2005 01:15:18

ok CooL,merci

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

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

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 !

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

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)

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 ?

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

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.

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

Comparez les prix

CalendriCode

Février 2012
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
272829    

Consulter la suite du CalendriCode

Photothèque

 
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

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,608 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales