begin process at 2010 03 20 10:48:21
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Sécurité & Cryptage

 > PROGRAMME DE PROTECTION PASSWORD CRYPTÉ AVEC GESTION DU CARACTÈRE ' * '

PROGRAMME DE PROTECTION PASSWORD CRYPTÉ AVEC GESTION DU CARACTÈRE ' * '


 Information sur la source

Note :
9 / 10 - par 3 personnes
9,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Sécurité & Cryptage Niveau :Débutant Date de création :07/12/2004 Date de mise à jour :07/12/2004 16:14:44 Vu :10 827

Auteur : Jarod1980

Ecrire un message privé
Commentaire sur cette source (12)
Ajouter un commentaire et/ou une note

 Description

J'ai vu sur le site que plusieurs personnes proposent des programmes de
mot de passe.
Le problème c'est que la plupart du temps les mots de passes
apparaîssent en clair lorsqu'on ouvre le programme avec un éditeur hexaécimal.
J'ai donc développé un programme de mot de passe crypté
avec gestion du caractère '*' lors de la saisie du mot de passe.
Le premier programme consiste à choisir son mot de passe.
Celui-ci sera crypté par la méthode de cryptage de Cesar
puis stocker dans un fichier password.txt.
Le deuxième programme c'est le programme de protection.
L'utilisateur entre son mot de passe, le programme stock et crypte la saisie
de l'utilisateur et le compare à la chaîne de caractères du fichier password.
J'ai choisi comme algorithme de cryptage la méthode Cesar
pour commencer au tant faire simple.
PS: J'ai mis les deux sources sur la même page, donc n'oublier
pas de coller séparement le code de chaque programme dans 2 fichiers differents.

Source

  • /*****************************************/
  • /* Programme permettant à l'utilisateur de */
  • /* définir son mot de passe */
  • /* le mot de passe sera crypté et stocké dans le */
  • /* fichier password.txt */
  • /* */
  • /* cryptage : Methode de Cesar */
  • /* Developpé par : Jarod1980 */
  • /* */
  • /*****************************************/
  • #include <stdio.h>
  • #include <stdlib.h>
  • #include <string.h>
  • #define LONG_MOT 100
  • void CESAR(char *, int cle); /* --- PROTOTYPE FONCTION CESAR --- */
  • int main(int argc, char *argv[])
  • {
  • char passcheck[LONG_MOT];
  • int cle;
  • FILE *fichier;
  • fichier=fopen("password.txt","wt");
  • cle=15; /* clé de cryptage vous pouvez la changer à
  • condition que : 1<cle<25 */
  • printf("\nEnter Password:"); /* choix de votre mot de passe */
  • scanf("%s",&passcheck); /* on le stock dans passcheck */
  • CESAR(passcheck,cle); /* on appel la fonction CESAR */
  • fprintf(fichier,"%s\n",passcheck); /* on sauvegarde le password crypté
  • dans password.txt */
  • fclose(fichier); /* on ferme le fichier */
  • return 0;
  • }
  • void CESAR(char *mot, int cle) /* ---- DEFINITION Fonction Cesar ---- */
  • {
  • int i, n;
  • for (i=0;i<strlen(mot)-1;i++)
  • {
  • mot[i] = tolower(mot[i]); /*CONVERSION en minuscule au cas où*/
  • if (mot[i] != 32) /*CHIFFREMENT des caracteres autres que ESPACE*/
  • {
  • n = mot[i]+cle; /*CONVERSION du Char mot[i] en Int */
  • if (n<=122) /*CHIFFREMENT de mot[]*/
  • {
  • mot[i] = n; /*AFFECTATION de Int n dans Char mot[i]*/
  • }
  • else
  • {
  • n = n - 26;
  • mot[i] = n; /*AFFECTATION de Int n dans Char mot[i]*/
  • }
  • }
  • else /*CHIFFREMENT de ESPACE en ESPACE*/
  • {
  • mot[i] = 32;
  • }
  • }
  • mot[strlen(mot)-1] = 0; /*AFFECTATION ('\0') (NULL) (Code 0)
  • en fin de chaine*/
  • }
  • -------------%<---------COUPER-----ICI-------%<------------COUPER-----ICI-----%<-------------------
  • /*******************************/
  • /* Programme de protection password*/
  • /* avec gestion du caractère '*' lors de*/
  • /* la saisie au clavier par l'utilisateur */
  • /* de son mot de passe. */
  • /* */
  • /* Developpé par: Jarod1980 */
  • /*******************************/
  • #include <stdio.h>
  • #include <stdlib.h>
  • #include <string.h>
  • #define LONG_MOT 100
  • void CESAR(char *, int cle); /* --- PROTOTYPE FONCTION CESAR --- */
  • int main(int argc, char *argv[])
  • {
  • char pass[LONG_MOT];
  • char str[100];
  • int cle;
  • int num;
  • FILE *fichier;
  • fichier=fopen("password.txt","rb");
  • cle=15;
  • fscanf(fichier,"%s",&str); /* recupere la chaine de caractères
  • ds fichier et on la stock dans str */
  • fclose(fichier); /* On ferme fichier */
  • do {
  • printf("\nEnter Password:");
  • if (num !=100) {
  • num=0; /*GESTION*/
  • while((pass[num]=getch()) != 13) { /*DU*/
  • putchar('*'); /*CARACTERE*/
  • num++; /*ETOILE*/
  • }}
  • pass[num]='\0';
  • CESAR(pass,cle); /* On appel Cesar pour crypter la saisie */
  • }
  • while(strcmp (str,pass) != 0); /* On compare les
  • 2 chaînes de caractères */
  • printf("\n\nHello!");
  • return 0;
  • }
  • void CESAR(char *mot, int cle) /* ---- DEFINITION Fonction Cesar ---- */
  • {
  • int i, n;
  • for (i=0;i<strlen(mot)-1;i++)
  • {
  • mot[i] = tolower(mot[i]); /*CONVERSION en minuscule au cas où*/
  • if (mot[i] != 32) /*CHIFFREMENT des caracteres autres que ESPACE*/
  • {
  • n = mot[i]+cle; /*CONVERSION du Char mot[i] en Int*/
  • if (n<=122) /*CHIFFREMENT de mot[]*/
  • {
  • mot[i] = n; /*AFFECTATION de Int n dans Char mot[i]*/
  • }
  • else
  • {
  • n = n - 26;
  • mot[i] = n; /*AFFECTATION de Int n dans Char mot[i]*/
  • }
  • }
  • else /*CHIFFREMENT de ESPACE en ESPACE*/
  • {
  • mot[i] = 32;
  • }
  • }
  • mot[strlen(mot)-1] = 0; /*AFFECTATION ('\0') (NULL) (Code 0)
  • en fin de chaine */
  • }
/*****************************************/
/* Programme permettant à l'utilisateur de              */
/* définir son mot de passe                                      */
/* le mot de passe sera crypté et stocké dans le     */
/* fichier password.txt                                              */
/*                                                                              */
/* cryptage : Methode de Cesar                               */
/* Developpé par : Jarod1980                                  */
/*                                                                              */
/*****************************************/

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

#define LONG_MOT 100


void CESAR(char *, int cle); /* --- PROTOTYPE FONCTION CESAR --- */

int main(int argc, char *argv[])
{
 
 char passcheck[LONG_MOT];
 int cle;
 
 FILE *fichier;
 fichier=fopen("password.txt","wt");
 
 cle=15; /* clé de cryptage vous pouvez la changer à 
                  condition que : 1<cle<25 */  

 printf("\nEnter Password:");  /* choix de votre mot de passe */
 scanf("%s",&passcheck);  /* on le stock dans passcheck */  
 CESAR(passcheck,cle); /* on appel la fonction CESAR */
 fprintf(fichier,"%s\n",passcheck); /* on sauvegarde le password crypté 
                                              dans password.txt */
 fclose(fichier); /* on ferme le fichier */
 return 0;
}
void CESAR(char *mot, int cle) /* ---- DEFINITION Fonction Cesar ---- */
{
int i, n;
for (i=0;i<strlen(mot)-1;i++) 
{
mot[i] = tolower(mot[i]); /*CONVERSION en minuscule au cas où*/
if (mot[i] != 32) /*CHIFFREMENT des caracteres autres que ESPACE*/
{
n = mot[i]+cle; /*CONVERSION du Char mot[i] en Int */
if (n<=122) /*CHIFFREMENT de mot[]*/
{
mot[i] = n; /*AFFECTATION de Int n dans Char mot[i]*/
}
else
{
n = n - 26;
mot[i] = n; /*AFFECTATION de Int n dans Char mot[i]*/
}
}
else /*CHIFFREMENT de ESPACE en ESPACE*/
{
mot[i] = 32;
}
}
mot[strlen(mot)-1] = 0; /*AFFECTATION ('\0') (NULL) (Code 0) 
                                                 en fin de chaine*/
} 

-------------%<---------COUPER-----ICI-------%<------------COUPER-----ICI-----%<-------------------

/*******************************/
/* Programme de protection password*/ 
/* avec gestion du caractère '*' lors de*/ 
/* la saisie au clavier par l'utilisateur    */
/* de son mot de passe.                       */
/*                                                          */
/* Developpé par: Jarod1980               */
/*******************************/

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

#define LONG_MOT 100

void CESAR(char *, int cle); /* --- PROTOTYPE FONCTION CESAR --- */

int main(int argc, char *argv[])
{
  char pass[LONG_MOT];
  char str[100];
  int cle;
  int num;
  FILE *fichier;
  fichier=fopen("password.txt","rb");

  cle=15;
  fscanf(fichier,"%s",&str); /* recupere la chaine de caractères 
                      ds fichier et on la stock dans str */
  fclose(fichier);     /* On ferme fichier */
  
  do {
  printf("\nEnter Password:");
  if (num !=100) {                                     
  num=0;                                              /*GESTION*/
  while((pass[num]=getch()) != 13) {    /*DU*/
  putchar('*');                                      /*CARACTERE*/
  num++;                                          /*ETOILE*/
  }}                                                           
  pass[num]='\0';                                      

  CESAR(pass,cle); /* On appel Cesar pour crypter la saisie */
  }
  while(strcmp (str,pass) != 0); /* On compare les 
                                              2 chaînes de caractères */
  printf("\n\nHello!");
  return 0;
}
void CESAR(char *mot, int cle) /* ---- DEFINITION Fonction Cesar ---- */
{
int i, n;
for (i=0;i<strlen(mot)-1;i++)
{
mot[i] = tolower(mot[i]); /*CONVERSION en minuscule au cas où*/
if (mot[i] != 32) /*CHIFFREMENT des caracteres autres que ESPACE*/
{
n = mot[i]+cle; /*CONVERSION du Char mot[i] en Int*/
if (n<=122) /*CHIFFREMENT de mot[]*/
{
mot[i] = n; /*AFFECTATION de Int n dans Char mot[i]*/
}
else
{
n = n - 26;
mot[i] = n; /*AFFECTATION de Int n dans Char mot[i]*/
}
}
else /*CHIFFREMENT de ESPACE en ESPACE*/
{
mot[i] = 32;
}
}
mot[strlen(mot)-1] = 0; /*AFFECTATION ('\0') (NULL) (Code 0) 
                                         en fin de chaine */
}

 Conclusion

Voila, le but maintenant c'est de mettre un algorithme un
peu plus balèze que la méthode de Cesar.
Si vous avez des idées ou des remarques n'hésiter
à me contacter.


 Historique

07 décembre 2004 16:05:48 :
-
07 décembre 2004 16:14:44 :
J'ai juste refait la mise en forme de mon code.

 Sources du même auteur

Source avec une capture FRACTALE NEWTON-RAPHSON VERSION GLUT
Source avec Zip FAST FOURIER TRANSFORM
TRANSFORMEE DE FOURIER DISCRETE
Source avec une capture FRACTALE TREE (ARBRE) VERSION GLUT
Source avec une capture COURBE DE GUMOWSKI & MIRA VERSION GLUT

 Sources de la même categorie

Source avec Zip Source avec une capture CRYPTEUR-DÉCRYPTEUR-IP par antho974
Source avec Zip Source avec une capture ELGAMALCIPHER par CHAR As Human
Source avec Zip CRYPTER-DECRYPTER EN UTILISANT L'ALGORITHME DE CESAR par Antoinejdu44
Source avec Zip CRYPT-O-MATIC "DARKCHOCOLATE" par FrancoisGauthier
Source avec Zip CREEP SECURITY ALGORITHM par nanonavich

Commentaires et avis

Commentaire de AlexMAN le 07/12/2004 21:52:19

Peut on parler de cryptage avec la methode de cesar ? Pck c pas trop du 'cryptage' je trouve..

Commentaire de Nebula le 08/12/2004 12:21:53

Ben César c'est bien une méthode de cryptage... Triviale, mais bon. Je propose Vigénère pour la version 2.0 ! lol

Blague à part, le mieux est encore d'utiliser une méthode non-réversible, comme le MD5 (les systèmes UNIX stockent leurs mots de passe avec ce genre d'algorithmes). Le principe est alors d'encoder le pass entré et de le comparer avec celui stocké, s'ils sont identiques le login est accepté.

Bien sûr, il faut avoir un faible taux de collisions pour qu'une telle méthode soit fiable (ce que garantit le MD5). La seule solution pour craquer un pass encodé ainsi est le brute-force ou l'attaque par dictionnaire, si le pass est mal choisi...

Commentaire de Jarod1980 le 08/12/2004 13:54:34

Effectivement la methode de cesar est une methode de cryptage. Comme le dis Nebula elle est triviale. En effet,
Ce code de chiffrement est un des plus anciens, dans la mesure où Jules César l'aurait utilisé. Le principe de codage repose sur l'ajout d'une valeur constante à l'ensemble des caractères du message, ou plus exactement à leur code ASCII. Il s'agit donc simplement de décaler l'ensemble des valeurs des caractères du message d'un certain nombre de positions, c'est-à-dire en quelque sorte de substituer chaque lettre par une autre. Par exemple, en décalant le message "COMMENT CA MARCHE" de 3 positions, on obtient "FRPPHQW FD PDUFKH". Lorsque l'ajout de la valeur donne une lettre dépassant la lettre Z, il suffit de continuer en partant de A, ce qui revient à effectuer un modulo 26.
Ce système de cryptage est certes simple à mettre en oeuvre, mais il a pour inconvénient d'être totalement symétrique, cela signifie qu'il suffit de faire une soustraction pour connaître le message initial. Une méthode primaire peut consister à une bête soustraction des nombres 1 à 26 pour voir si l'un de ces nombres donne un message compréhensible.
L'idée de Nebula sur le codage MD5 est bonne. Je vais donc travailler sur la methode MD5. Donc peut être une autre source avec cette methode.

Commentaire de Fugitif2005 le 05/01/2005 13:13:40

Concernant la saisie du mot de passe masqué (avec des *), ça fait plusieurs fois que je vois une solution utilisant la méthode getch(). MAIS D'OU SORT CETTE FONCTION ?? Elle ne se trouve dans aucune des librairies standards (comme celles inclues dans le programme ici). Je ne la trouve nulle part ailleurs sur internet !
Sinon, comment alors désactiver l'affichage des caractères saisis sur le terminal ??
Merci

Commentaire de AlexMAN le 05/01/2005 17:40:33

getch() est dans conio.h qui est normalement fourni avec DevC++ et VC++, mais bon, comme tu dis, c pas standard...

++

Commentaire de Fugitif2005 le 05/01/2005 20:55:02

Merci beaucoup, j'ai pu l'utiliser avec conio.h

Par contre elle semble bien marcher dans une console sous DOS (pas d'echo aux touches tapées), mais pas dans un terminal comme on peut en trouver sous CBuilder par exemple

Commentaire de noSnoR le 05/03/2005 21:52:21

j'ai quelques probleme avec devC++ ... un message m'indique que tolower n'est pas déclaré...

Commentaire de Jarod1980 le 06/03/2005 11:01:17

tolower est normalement reconnu avec Dev-C++. J'ai compilé mon code avec Dev-C++ 4 et ça compile sans problèmes; Ca compile également sans problèmes avec Dev-Cpp 5.

Commentaire de Uims le 05/05/2005 13:37:25

Moi j'aime bien ta source (merci de ne pas l'avoir mis dans un zip).
(nombreux commentaires ;-)).
Pour des debutants je trouve ce genre de source utile pour comprendre quelque chose au cryptage.
Et effectivement pour un mot de passe j'ai pas penser au cryptage!

Bonne continuation!

Uims

Commentaire de julien_boss le 23/03/2006 13:05:37

Pourquoi pas le cryptage XOR ? Très efficace aussi

Commentaire de Jarod1980 le 23/03/2006 17:16:07

Le Xor est aussi une possibilté mais aussi facile à cracker que la méthode de cryptage que je propose dans ma source. Une autre solution serait de faire avec du md5. J'ai d'ailleurs fait une mise à jour de ma source mais je ne l'ai pas encore publiée.

Commentaire de larson88 le 13/06/2009 15:42:33

Pour utiliser le programme sous devc++, il faut parfois rajouter des includes suivant la version (#include <iostream> (pour utiliser tolower) ; et #include <conio.h> (pour utiliser getch))

 Ajouter un commentaire




Nos sponsors


Sondage...

Comparez les prix


HTC Magic

Entre 429€ et 429€

CalendriCode

Mars 2010
LMMJVSD
1234567
891011121314
15161718192021
22232425262728
293031    

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,796 sec (4)

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