CRYPTAGE-DECRYPTAGE : TURBO C++ 2 DEVC++ 4 EN LANGAGE C

/* code ecrit avec turbo c++ 2  devc++ 4 en langage C */
/* ecrit par cmarsc 28-12-2002 */
/* cryptage-decryptage simple */

/*
le principe de l'algorithme est le suivant chaque caractere a une valeur ASCII
de 0 a 255 sous DOS. Pour le cryptage le mot saisi au clavier est decompose 
caractere par caractere, on retourne sa valeur ASCII : A = 65 B = 66  C = 67 ...
puis on lui ajoute un nombre PSEUDO ALEATOIRE pour creer un effet de decalage
comme A qui valait 65 va devenir par exemple 70 (+5), mais dans ce cas la le
nombre ajoute sera different a chaque saisie meme pour un meme mot obtenant
de fait un cryptage different.
pareillement pour le decryptage au lieu d'ajouter on soustrait et on reconstitue
le mot tape. En temps normal ces informations sont ecrites dans un fichier puis
lus.
naturellement on peut faire plus complique, mais le but n'est pas de vous donner
la migraine du moins pour le moment ;-) en verra ça plus tard c'est promis. 
parole de scout ou presque.

PS : by the way PAPI NEW YEAR 2003. ;-)
cmarsc 

*/

#include <stdio.h>
#include <stdlib.h>                    /* srand rand */
#include <conio.h>                     /* dev c++4 <conio.c> */
#include <string.h>                    /* memset-strlen-strcmp */
#include <time.h>                      /* time(NULL) */

#define KEY_ENTER                13    /* touches du clavier ENTREE */
#define KEY_ESC                  27    /* ESC */
#define KEY_RETURN               '\b'  /* RETURN pour effacer */

#define LONGUEUR_MINI_DU_MOT      5
#define LONGUEUR_MAXI_DU_MOT     15
#define VALEUR_ASCII_MINI        30
#define VALEUR_ASCII_MAXI        75
#define NBRE_DE_TENTATIVES_MAXI   3

static char *saisir_au_clavier(int type_de_saisi);
static char *crypter(int val_ascii_ajoutee, char *mot_a_crypter);
static char *decrypter(int val_ascii_ajoutee, char *mot_a_decrypter);
                                
int verifier_mot_de_passe(char *vrai_mot_de_passe);
void effacer_ecran(void); 

enum type_de_saisi {LOGIN, MOT_DE_PASSE };
enum reponse {ACCESS_REFUSE, ACCESS_AUTORISE };

char *menu_access[] = {
    "REFUSE :-(",
    "AUTORISE :-)"
};

int main(void) {

	char touche_clavier = '\0';
    char *resultat_de_la_saisie; 
    char *resultat_du_cryptage; 
    char *resultat_du_decryptage;
	char  vrai_mot_de_passe[LONGUEUR_MAXI_DU_MOT];

    int   access_autorise_ou_pas, nbre_de_tentatives;   
    int   val_ascii_ajoutee;


/* ESC pour QUITTER le programme */
while (touche_clavier != KEY_ESC ) {

    effacer_ecran();

    textcolor(LIGHTGREEN);
	resultat_de_la_saisie = saisir_au_clavier(LOGIN);
	gotoxy(1,1);  /* LOGIN */
	cprintf ("Votre LOGIN est : %-15.15s",resultat_de_la_saisie);

    textcolor(LIGHTCYAN);
    resultat_de_la_saisie = saisir_au_clavier(MOT_DE_PASSE);    
    gotoxy(1,3);  /* MOT_DE_PASSE */
    cprintf ("Mot de passe masque au clavier : %-15.15s",resultat_de_la_saisie);

    strcpy(vrai_mot_de_passe,resultat_de_la_saisie);

	/* initialiser les nombres pseudos aleatoires */
    /* pour creer un effet de decalage */
    srand( (unsigned) time(NULL) );
	val_ascii_ajoutee =  rand() % (VALEUR_ASCII_MAXI) + VALEUR_ASCII_MINI;


    textcolor(LIGHTBLUE);
    resultat_du_cryptage = crypter(val_ascii_ajoutee,resultat_de_la_saisie);    
    gotoxy(1,5);
    cprintf ("Mot de passe crypte : %-15.15s",resultat_du_cryptage);
    
    textcolor(YELLOW);
    resultat_du_decryptage = decrypter(val_ascii_ajoutee,resultat_du_cryptage);    
    gotoxy(1,7);
    cprintf ("Mot de passe decrypte : %-15.15s",resultat_du_decryptage);

    textcolor(LIGHTGRAY);
    gotoxy(1,9);
    cprintf ("Valeur ASCII ajoutee : %3d", val_ascii_ajoutee);
                
        nbre_de_tentatives = 0;
    do {

        nbre_de_tentatives++;
        textcolor(CYAN);
        gotoxy(1,12);
        cprintf ("Verification numero %d", nbre_de_tentatives);
        textcolor(WHITE);

        /* retourne ZERO si ACCESS REFUSE et 1 si ACCESS AUTORISE */
		access_autorise_ou_pas = verifier_mot_de_passe(vrai_mot_de_passe);

        gotoxy(1,15);  /* afficher le message de reponse */
        cprintf ("ACCESS : %s%5c",menu_access[access_autorise_ou_pas],'\0');

		if (nbre_de_tentatives >= NBRE_DE_TENTATIVES_MAXI) break;

    } while (access_autorise_ou_pas != ACCESS_AUTORISE);

    textcolor(LIGHTMAGENTA);
    gotoxy(1,23);  
    cprintf("Appuyer pour continuer %27c ESC pour quitter le programme",'\0');
    touche_clavier = getch();


} /* fin de while (touche_clavier != KEY_ESC) */


    return EXIT_SUCCESS;     
} /* fin de la fonction main */


static char *saisir_au_clavier(int type_de_saisi) {

    int col = 1, ligne = 13;
    int i = 0;
    static char mot_saisi[LONGUEUR_MAXI_DU_MOT + 1];

    /* remplir le tableau mot_saisi de caracteres vides */
    memset (mot_saisi, '\0', LONGUEUR_MAXI_DU_MOT + 1);

mot_trop_court:

    /* afficher l'invite */
    gotoxy(col,ligne);
    if (type_de_saisi == LOGIN) cprintf("VOTRE LOGIN S.V.P"); 
    if (type_de_saisi == MOT_DE_PASSE) cprintf("MOT DE PASSE S.V.P"); 
 
    while (i < LONGUEUR_MAXI_DU_MOT) {

        /* deplacement vers la droite */
        gotoxy(20 + col + i,ligne);

        /* stocker les caracteres dans le tableau */  
        mot_saisi[i] = getch(); 

        /* annuler le caractere tape */
        if (mot_saisi[i] == KEY_RETURN) {

             mot_saisi[i] = '\0';  
             if (strlen(mot_saisi) > 0) {
                 /* retour a la position precedente du curseur */
                 i--; 
                 gotoxy(20 + col + i,ligne); 
                 cprintf("%1c",'\0');  
             } /* fin de if (strlen(mot_saisi) */
            
             
        } else {

            /* afficher les caracteres du LOGIN */
            if (type_de_saisi == LOGIN) cprintf("%1c",mot_saisi[i]); 

            /* afficher l'asterisque pour dissimuler la saisie */ 
            if (type_de_saisi == MOT_DE_PASSE) cprintf("*"); 

            /* confirmer la fin de la saisie par entree */
            if (mot_saisi[i] == KEY_ENTER) break; 

            /* abandonner pour retourner dans main */
            if (mot_saisi[i] == KEY_ESC) break; 

            i++; /* incrementation de i */

       } /* fin de if (mot_saisi[i] == KEY_RETURN) */

    }; /* fin de while (i < ...) */ 

    /* effacer la ligne avec 45 espaces */
    gotoxy(1,ligne); cprintf("%45c",'\0');

    if (mot_saisi[i] != KEY_ESC) 
       if (strlen(mot_saisi) < LONGUEUR_MINI_DU_MOT) goto mot_trop_court;

    mot_saisi[i] = '\0';
    return (mot_saisi[i] == KEY_ESC) ? "\0": mot_saisi;     

} /* fin de la fonction saisir_mot */
                 
    
static char *crypter(int val_ascii_ajoutee, char *mot_a_crypter) {
    
    static char resultat_du_cryptage[LONGUEUR_MAXI_DU_MOT + 1];
    int longueur_du_mot_a_crypter = strlen(mot_a_crypter);
    int i;

    
    /* decomposer le mot_a_crypter et lui attribuer une autre valeur ASCII */
    for (i = 0; i < longueur_du_mot_a_crypter; i++) { 

       gotoxy(50,1 + i);  /* afficher les details */ 
       cprintf ("%2d %1c %3d +%3d = %3d %1c",i, mot_a_crypter[i],
       mot_a_crypter[i] ,val_ascii_ajoutee, 
      (val_ascii_ajoutee + i) + mot_a_crypter[i], 
      (val_ascii_ajoutee + i) + mot_a_crypter[i]);
         
        // );

        /* val_ascii_ajoutee + i permet d'avoir des valeurs differentes*/
        /* meme si les caracteres sont identiques */
        resultat_du_cryptage[i] = (val_ascii_ajoutee + i) + mot_a_crypter[i];
        
    } /* fin de for (i ...) */

    resultat_du_cryptage[i] = '\0';
    return resultat_du_cryptage;
} /* fin de la fonction crypter */
   

static char *decrypter(int val_ascii_ajoutee, char *mot_a_decrypter) {

    int longueur_du_mot_a_decrypter = strlen(mot_a_decrypter);
    static char resultat_du_decryptage[LONGUEUR_MAXI_DU_MOT + 1];
    int i;  


    /* decomposer le mot_a_decrypter et lui attribuer une autre valeur ASCII */
    for (i = 0; i < longueur_du_mot_a_decrypter; i++) { 

        gotoxy(72,1+i);  /* afficher les details */
        cprintf ("%2d  %1c %1c",i, mot_a_decrypter[i], 
                (mot_a_decrypter[i] - val_ascii_ajoutee) - i);
        
        resultat_du_decryptage[i] = (mot_a_decrypter[i] - val_ascii_ajoutee)-i;
        
    } /* fin de for (i ...) */

    resultat_du_decryptage[i] = '\0';
    return resultat_du_decryptage;

} /* fin de la fonction decrypter */
  

int verifier_mot_de_passe(char *vrai_mot_de_passe) {

    int reponse_apres_verification;

    char *resultat_de_la_saisie;
    resultat_de_la_saisie = saisir_au_clavier(MOT_DE_PASSE);   

    /* comparer le vrai mot de passe a celui saisi */
    if ( strcmp(vrai_mot_de_passe,resultat_de_la_saisie) == 0 ) {

         textcolor(155); /* message en violet */            
         reponse_apres_verification = ACCESS_AUTORISE;

    } else {

         textcolor(LIGHTRED);   /* message en rouge vif */      
         reponse_apres_verification = ACCESS_REFUSE;

    } /* fin de if (strcmp ...) */

    return reponse_apres_verification;
} /* fin de la fonction verifier_mot_de_passe */


void effacer_ecran(void) {
    int i; 

    textcolor(BLACK); 
    for (i = 1; i < 25; i++) {
       gotoxy (1, 25); cprintf("%80c\n",'\0');
    }    

    return ;
} /* fin de la fonction effacer_ecran */