CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2012 02 05 03:56:51

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

CRYPTAGE RSA

Information sur la source

Note :

7,93 / 10

Catégorie :Sécurité & Cryptage Niveau :Initié Date de création :31/07/2001 Date de mise à jour :02/04/2002 21:25:49 Vu :32 930

Auteur : Kreator

Ecrire un message privé

Site perso

Commentaire sur cette source (24)

Ajouter un commentaire et/ou une note

Description

Crypte selon la méthode RSA en travaillant sur les nombres premiers...

Source

/*
Cryptographie
Programme principal
Version 1.1
*/
#include <conio.h>
#include <stdio.h>
#include <string.h>
#include <alloc.h>
#include <math.h>
#include <time.h>
#include <stdlib.h>
void menu(void);
void quitter(void);
void erreur(void);
void menu_crypto(void);
void menu_calcul(void);
void pgcd(void);
void choix_calcul(void);
void modulo(void);
void p_e_e(void);
void primarite(void);
void choix_crypto(void);
void lecture(void);
void comparer(void);
unsigned long int crypt(unsigned char k,unsigned long int n,unsigned long int e);
unsigned char decrypt( unsigned long int k,unsigned long int d,unsigned long int n);
void crypter(void);
void decrypter(void);
void inscri(void);
int p_e_e2(int x);
void pgcd2(int a,int b,int* taille,int* tab[]);
void decomp(int*s,int*q,int*r,int*k);
int cle_priv(int e,int z);
void pq(int* p,int* q);
void decomposition(void);
void main(void)
{
printf("\n\n\n\n\n\n\n\n\t\t\t CRYPTOGRAPHIE\n\n\n\n\n\n\n\n\n");
printf("\n\n\t\t\t version 1.0");
getch();
clrscr();
menu();
getch();
}
/****************************MENU PRINCIPAL************************************/
void menu(void)
{
int choix=0;
printf("\n\n\t\t\t ****************\n");
printf("\t\t\t *MENU PRINCIPAL*\n");
printf("\t\t\t ****************\n\n\n\n");
printf("\t TAPEZ :\n\n\n\n");
printf("\t\t1\t POUR\t UTILISER LA CRYPTOGRAPHIE\n\n");
printf("\t\t2\t POUR\t REALISER DIVERS CALCULS\n\n");
printf("\t\t3\t POUR\t QUITTER LE LOGICIEL\n\n\n");
printf("\t CHOIX : ");
scanf("%d",&choix);
switch(choix)
{
case 1 : clrscr();
menu_crypto();
break;
case 2 : clrscr();
menu_calcul();
break;
case 3 : quitter();
break;
default : erreur();
}
}
/***************************MENU CRYPTOGRAPHIE*********************************/
void menu_crypto(void)
{
int choix=0;
printf("\n\n\t\t\t ********************\n");
printf("\t\t\t *MENU CRYPTOGRAPHIE*\n");
printf("\t\t\t ********************\n\n\n\n");
printf("\t TAPEZ :\n\n\n\n");
printf("\t\t1\t POUR\t VOUS INSCRIRE\n\n");
printf("\t\t2\t POUR\t CRYPTER\n\n");
printf("\t\t3\t POUR\t DECRYPTER\n\n");
printf("\t\t4\t POUR\t LIRE UN FICHIER\n\n");
printf("\t\t5\t POUR\t COMPARER 2 FICHIERS\n\n");
printf("\t\t6\t POUR\t MENU PRECEDENT\n\n\n");
printf("\t CHOIX : ");
scanf("%d",&choix);
switch(choix)
{
case 1 : inscri();
break;
case 2 : clrscr();
crypter();
clrscr();
choix_crypto();
break;
case 3 : clrscr();
decrypter();
clrscr();
choix_crypto();
break;
case 4 : clrscr();
lecture();
clrscr();
choix_crypto();
break;
case 5 : clrscr();
comparer();
clrscr();
choix_crypto();
break;
case 6 : clrscr();
menu();
break;
default : erreur();
}
}
/*******************************CRYPTER****************************************/
void crypter(void)
{
FILE *source_crypt;
FILE *res_crypt;
unsigned char c;
unsigned long int i=0;
unsigned long int k,n,e;
char nom_fichier[20];
printf("\n\n\t\t\t *********\n");
printf("\t\t\t *CRYPTER*\n");
printf("\t\t\t *********\n\n\n\n");
fflush(stdin);
printf("Donner le nom du fichier source avec son extension : ");
gets(nom_fichier);
printf("\n\n\n\tdonner votre cle publique n : ");
scanf("%d",&n);
printf("\n\n\n\tdonner votre cle publique e : ");
scanf("%d",&e);
source_crypt=fopen(nom_fichier,"rb");
if(source_crypt==NULL)
{
printf("Impossible d'ouvrir le fichier source.\n");
}
res_crypt=fopen("result.cry" , "wb");
if(res_crypt==NULL)
{
printf("Impossible d'ouvrir le fichier resultat.\n");
}
clrscr();
printf("\n\n\t\tATTENDEZ SVP PENDANT LE CRYPTAGE.");
while((feof(source_crypt)==0) && (fread(&c,sizeof(unsigned char),1,source_crypt)!=0))
{
fseek(source_crypt,sizeof(unsigned char)*i,SEEK_SET);
fread(&c,sizeof(unsigned char),1,source_crypt);
k=crypt(c,n,e);
fwrite(&k,sizeof(unsigned long int),1,res_crypt);
i=i+1;
}
fclose(source_crypt);
fclose(res_crypt);
printf("\n\n\n\n\n\n\n\n\n\nLe cryptage de votre fichier est termine.");
printf("\n\nvotre fichier crypter se nomme result.cry");
getch();
}
/******************************FONCTION CRYPTAGE*******************************/
unsigned long int crypt(unsigned char k,unsigned long int n,unsigned long int e)
{
unsigned long int i,res=1,nbre;
nbre=((unsigned long int)k);
for(i=0;i<e;i++)
{
res = res * nbre;
res=fmod(res,n);
}
return res;
}
/*******************************DECRYPTER**************************************/
void decrypter(void)
{
FILE *source;
FILE *res_decrypt;
char l;
unsigned long int h=0;
unsigned long int d,n;
unsigned long int lect_int;
char nom_fichier[20],nom_fin[20];
printf("\n\n\t\t\t ***********\n");
printf("\t\t\t *DECRYPTER*\n");
printf("\t\t\t ***********\n\n\n\n");
fflush(stdin);
printf("Donner le nom du fichier avec son extension : ");
gets(nom_fichier);
printf("Donner le nom du fichier de destination avec son extension : ");
gets(nom_fin);
printf("\n\n\n\tdonner votre cle prive n : ");
scanf("%d",&n);
printf("\n\n\n\tdonner votre cle prive d : ");
scanf("%d",&d);
source=fopen(nom_fichier , "rb");
if(source==NULL)
{
printf("Impossible d'ouvrir le fichier a decrypter.\n");
erreur();
}
res_decrypt=fopen(nom_fin , "wb");
if(res_decrypt==NULL)
{
printf("Impossible d'ouvrir le fichier resultat.\n");
erreur();
}
clrscr();
printf("\n\n\t\tATTENDEZ SVP PENDANT LE DECRYPTAGE.");
while((feof(source)==0) && (fread(&lect_int,sizeof(unsigned long int),1,source)!=0))
{
fseek(source,sizeof(unsigned long int)*h,SEEK_SET);
fread(&lect_int,sizeof(unsigned long int),1,source);
l=decrypt(lect_int,d,n);
fwrite(&l,sizeof(unsigned char),1,res_decrypt);
h=h+1;
}
fclose(source);
fclose(res_decrypt);
printf("\n\n\n\n\n\n\n\n\n\nLe decryptage de votre fichier est termine.");
getch();
}
/****************************FONCTION DECRYPTAGE*******************************/
unsigned char decrypt(unsigned long int k,unsigned long int d,unsigned long int n)
{
unsigned long int i,res=1;
unsigned char x;
for(i=0;i<d;i++)
{
res=res*k;
res=fmod(res,n);
}
x=((unsigned char)res);
return x;
}
/********************************LECTURE***************************************/
void lecture(void)
{
int compteur_car;
int compteur_ligne;
int car_lect;
FILE *fichier;
char nom_fichier[20];
printf("\n\n\t\t\t**********************\n");
printf("\t\t\t*LECTURE D'UN FICHIER*\n");
printf("\t\t\t**********************\n\n\n");
fflush(stdin);
printf("Donner le nom du fichier a lire (avec son extension) : ");
gets(nom_fichier);
fichier=fopen(nom_fichier,"r");
if(fichier==NULL)
{
printf("\n\nImpossible d'ouvrir le fichier a lire.\n");
}
compteur_ligne=0;
compteur_car=0;
if(fichier!=NULL){
printf("\n\nLecture du fichier en cours.\n\n");
while((car_lect = fgetc(fichier))!=EOF)
{
compteur_car = compteur_car + 1;
printf("%c",car_lect);
if(compteur_car == 40)
{
compteur_car = 0;
compteur_ligne = compteur_ligne + 1;
}
if(compteur_ligne>=17)
{
compteur_car = 0;
compteur_ligne = 0;
getch();
clrscr();
}
}
printf("\n\n\nLa lecture du fichier est terminee.");
}
fclose(fichier);
getch();
}
/*******************************COMPARAISON************************************/
void comparer(void)
{
int compt=0;
int car_lect,car_lect2;
FILE *fichier;
FILE *fichier2;
char nom_fichier[20];
char nom_fichier2[20];
printf("\n\n\t\t\t ***************************\n");
printf("\t\t\t *COMPARAISON DE 2 FICHIERS*\n");
printf("\t\t\t ***************************\n\n\n");
fflush(stdin);
printf("Donner le nom du fichier source (avec son extension) : ");
gets(nom_fichier);
printf("Donner le nom du fichier a comparer (avec son extension) : ");
gets(nom_fichier2);
fichier=fopen(nom_fichier,"r");
fichier2=fopen(nom_fichier2,"r");
if(fichier==NULL)
{
printf("\n\nImpossible d'ouvrir le fichier source.\n");
}
if(fichier2==NULL)
{
printf("\n\nImpossible d'ouvrir le fichier a comparer.\n");
}
if((fichier!=NULL) && (fichier2!=NULL))
{
printf("\n\nLecture des fichiers en cours.\n\n");
while(((car_lect = fgetc(fichier))!=EOF)&&((car_lect2 = fgetc(fichier2))!=EOF))
{
if(car_lect!=car_lect2)
{
compt=compt+1;
}
}
if(compt==0)
{
printf("\n\nLes deux fichiers sont identiques.");
}
else
{
printf("\n\nIl y a %d caracteres d'ecart.",compt);
}
}
fclose(fichier);
fclose(fichier2);
getch();
}
/******************************CHOIX CRYPTO************************************/
void choix_crypto(void)
{
int choix;
printf("\n\n\n\n\t QUE SOUHAITEZ VOUS FAIRE ?\n\n\n\n\n");
printf("\t TAPEZ :\n\n\n");
printf("\t\t1\t POUR\t REVENIR AU MENU PRINCIPAL\n\n");
printf("\t\t2\t POUR\t REVENIR AU MENU CRYPTOGRAPHIE\n\n");
printf("\t\t3\t POUR\t QUITTER LE LOGICIEL\n\n\n");
printf("\t CHOIX : ");
scanf("%d",&choix);
switch(choix)
{
case 1 : clrscr();
menu();
break;
case 2 : clrscr();
menu_crypto();
break;
case 3 : quitter();
break;
default : erreur();
}
}
/******************************MENU CALCUL*************************************/
void menu_calcul(void)
{
int choix=0;
printf("\n\t\t\t *************\n");
printf("\t\t\t *MENU CALCUL*\n");
printf("\t\t\t *************\n\n\n");
printf("\t TAPEZ :\n\n\n\n");
printf("\t\t1\t POUR\t CALCULER LE PGCD DE 2 NOMBRES\n\n");
printf("\t\t2\t POUR\t DECOMPOSER UN NOMBRE EN NOMBRES PREMIERS\n\n");
printf("\t\t3\t POUR\t CALCULER UN MODULO\n\n");
printf("\t\t4\t POUR\t TESTER LA PRIMARITE D'UN NOMBRE\n\n");
printf("\t\t5\t POUR\t VOIR SI 2 NOMBRES SONT PREMIERS ENTRE EUX\n");
printf("\t\t6\t POUR\t MENU PRECEDENT\n\n\n");
printf("\t CHOIX : ");
scanf("%d",&choix);
switch(choix)
{
case 1 : clrscr();
pgcd();
clrscr();
choix_calcul();
break;
case 2 : clrscr();
decomposition();
clrscr();
choix_calcul();
break;
case 3 : clrscr();
modulo();
clrscr();
choix_calcul();
break;
case 4 : clrscr();
primarite();
clrscr();
choix_calcul();
break;
case 5 : clrscr();
p_e_e();
clrscr();
choix_calcul();
break;
case 6 : clrscr();
menu();
break;
default : erreur();
}
}
/*********************************CALCUL DU PGCD*******************************/
void pgcd(void)
{
int a,b,*reste,*s,*q;
reste=(int*)malloc(sizeof(int)); //initialisation de reste
s=(int*)malloc(sizeof(int)); //initialisation de s
q=(int*)malloc(sizeof(int)); //initialisation de q
printf("\n\n\t\t\t ****************\n");
printf("\t\t\t *CALCUL DU PGCD*\n");
printf("\t\t\t ****************\n\n\n");
printf("Donner le 1er entier : ");
scanf("%d",&a);
printf("\nDonner le 2eme entier : ");
scanf("%d",&b);
*s=a;
*q=b;
*reste=fmod(*s,*q);
while(*reste!=0 && *reste>0)
{
*s=*q;
*q=*reste;
*reste=fmod(*s,*q);
}
printf("\nle PGCD de %d et %d est %d.",a,b,*q);
getch();
}
/*********************************MODULO***************************************/
void modulo(void)
{
int res,x,y;
printf("\n\n\t\t\t ******************\n");
printf("\t\t\t *CALCUL DU MODULO*\n");
printf("\t\t\t ******************\n\n\n");
printf("\n\ncalcul de X modulo Y");
printf("\n\nDonner X : ");
scanf("%d",&x);
printf("\n\nDonner Y : ");
scanf("%d",&y);
res=fmod(x,y);
printf("\n\n%d modulo %d est egal a %d.",x,y,res);
getch();
}
/*******************************PRIMARITE**************************************/
void primarite(void)
{
int x,i,taille=0;
printf("\n\n\t\t\t***********************\n");
printf("\t\t\t*PRIMARITE D'UN NOMBRE*\n");
printf("\t\t\t***********************\n\n\n");
fflush(stdin);
printf("Donner un entier : ");
scanf("%d",&x);
if(x==0 || x==1)
{
printf("%d n'est pas premier.",x);
}
else
{
for(i=2;i<x;i++)
{
if(x%i==0)
{
taille=taille+1;
}
}
if(taille==0)
{
printf("%d est premier.",x);
}
else
{
printf("%d n'est pas premier.",x);
}
}
getch();
}
/**************************PREMIERS ENTRE EUX**********************************/
void p_e_e(void)
{
int a,b,*reste,*s,*q;
reste=(int*)malloc(sizeof(int)); //initialisation de reste
s=(int*)malloc(sizeof(int)); //initialisation de s
q=(int*)malloc(sizeof(int)); //initialisation de q
printf("\n\n\t\t\t ********************\n");
printf("\t\t\t *PREMIERS ENTRE EUX*\n");
printf("\t\t\t ********************\n\n\n");
printf("Donner le 1er entier : ");
scanf("%d",&a);
printf("\nDonner le 2eme entier : ");
scanf("%d",&b);
*s=a;
*q=b;
*reste=fmod(*s,*q);
while(*reste!=0 && *reste>0)
{
*s=*q;
*q=*reste;
*reste=fmod(*s,*q);
}
if(*q==1)
{
printf("\n\n%d et %d sont premiers entre eux.",a,b);
}
else
{
printf("\n\n%d et %d ne sont pas premiers entre eux.",a,b);
}
getch();
}
/****************************CHOIX CALCUL**************************************/
void choix_calcul(void)
{
int choix;
printf("\n\n\n\n\t QUE SOUHAITEZ VOUS FAIRE ?\n\n\n\n\n");
printf("\t TAPEZ :\n\n\n");
printf("\t\t1\t POUR\t REVENIR AU MENU PRINCIPAL\n\n");
printf("\t\t2\t POUR\t REVENIR AU MENU DES CALCULS\n\n");
printf("\t\t3\t POUR\t QUITTER LE LOGICIEL\n\n\n");
printf("\t CHOIX : ");
scanf("%d",&choix);
switch(choix)
{
case 1 : clrscr();
menu();
break;
case 2 : clrscr();
menu_calcul();
break;
case 3 : quitter();
break;
default : erreur();
}
}
/********************************ERREUR****************************************/
void erreur(void)
{
int choix;
printf("\nERREUR DE SAISIE.");
getch();
clrscr();
printf("\n\n\n\n\t\tSOUHAITEZ VOUS REVENIR AU MENU PRINCIPAL ?\n\n\n\n\n");
printf("\t TAPEZ :\n\n\n");
printf("\t\t1\t POUR\t REVENIR AU MENU PRINCIPAL\n\n");
printf("\t\t2\t POUR\t QUITTER LE LOGICIEL\n\n\n");
printf("\t CHOIX : ");
scanf("%d",&choix);
switch(choix)
{
case 1 : clrscr();
menu();
break;
case 2 : quitter();
break;
default : erreur();
}
}
/***********************************inscription********************************/
void inscri(void)
{
int p,q,e,z,d,n;
clrscr();
printf("\n\n\t\t\t\t*************\n");
printf("\t\t\t\t*INSCRIPTION*\n");
printf("\t\t\t\t*************\n\n\n");
pq(&p,&q);
n=p*q;
z=(p-1)*(q-1);
e=p_e_e2(z);
printf("\n\n\n\n\n\n\n\n\t( n : %d ; e : %d ) est votre cle publique.",n,e);
d=cle_priv(e,z);
printf("\n\n\n\n\t( n : %d ; d : %d ) est votre cle privee.",n,d);
getch();
getch();
getch();
clrscr();
choix_crypto();
}
/******************************************************************************/
int p_e_e2(int x)
{
int y,*tab[100000],*taille,rep,i;
taille=(int*)malloc(sizeof(int));
*taille=0;
for(i=0;i<100000;i++)
{
tab[i]=(int*)malloc(sizeof(int));
}
for(y=1;y<x;y++)
{
pgcd2(x,y,taille,tab);
}
randomize();
rep=*tab[rand()%*taille];
return rep;
}
/******************************************************************************/
void pgcd2(int a,int b,int* taille,int* tab[])
{
int *reste,*k,*s,*q;
reste=(int*)malloc(sizeof(int));
k=(int*)malloc(sizeof(int));
s=(int*)malloc(sizeof(int));
q=(int*)malloc(sizeof(int));
*s=a;
*q=b;
*reste=1;
decomp(s,q,reste,k);
while(*reste!=0&&*reste>0)
{
*s=*q;
*q=*reste;
decomp(s,q,reste,k);
}
if(*q==1)
{
*tab[*taille]=b;
*taille=*taille+1;
}
}
/******************************************************************************/
void decomp(int*s,int*q,int*r,int*k)
{
*k=0;
while(*s>=*q)
{
*s=*s-*q;
*k=*k+1;
}
*r=*s;
}
/******************************************************************************/
int cle_priv(int e,int z)
{
int d,i=0;
while((e*i)%z!=1)
{
i=i+1;
}
d=i;
return d;
}
/******************************************************************************/
void pq(int* p,int* q)
{
int t[200],i,y,j,taille=0;
for (i=3;i<200;i++)
{ y=0;
for(j=2;j<i;j++)
{
if(i%j==0)
{
y=y+1;
}
}
if(y==0)
{
//printf(" %d ",i);
t[taille]= i;
taille=taille+1;
}
}
randomize();
*p=t[rand()%taille];
*q=t[rand()%taille];
}
/*************************DECOMPOSITION****************************************/
void decomposition(void)
{
int prem[100000],puissance[100000];
int n,o,i,j,k,compt,taille=0;
printf("\n\n\t\t ***********************************\n");
printf("\t\t *DECOMPOSITION EN NOMBRES PREMIERS*\n");
printf("\t\t ***********************************\n\n\n");
printf("\nDonner 1 entier : ");
scanf("%d",&n);
printf("\n\n");
o=n;
for(i=2;i<o+1;i++)
{
compt=0;
for(j=2;j<i;j++)
{
if(i%j==0)
{
compt=compt+1;
}
}
if(compt==0)
{
prem[taille]=i;
taille=taille+1;
}
}
for(i=0;i<taille;i++)
{
k=0;
while(fmod(o,prem[i])==0)
{
o=o/prem[i];
k=k+1;
puissance[i]=k;
}
}
printf("%d =",n);
for(i=0;i<taille;i++)
{
if(puissance[i]!=0)
{
printf(" (%d",prem[i]);
printf("^");
printf("%d)",puissance[i]);
}
}
getch();
}
/******************************************************************************/
void quitter(void)
{
clrscr();
printf("\n\n\n\n\n\n\n\n\n");
printf(" * * * ****** ****** * * ****** * ****** \n");
printf(" * * * * * * * * * * * * * * \n");
printf(" ***** * * ****** *** * * * * * ****** \n");
printf(" * * * * * * * * * * * * * * \n");
printf(" * * ***** * * ****** * ****** * * * \n");
}
/*************************************END**************************************/

/*
Cryptographie
Programme principal
Version 1.1
*/


#include <conio.h>
#include <stdio.h>
#include <string.h>
#include <alloc.h>
#include <math.h>
#include <time.h>
#include <stdlib.h>



void menu(void);
void quitter(void);
void erreur(void);
void menu_crypto(void);
void menu_calcul(void);
void pgcd(void);
void choix_calcul(void);
void modulo(void);
void p_e_e(void);
void primarite(void);
void choix_crypto(void);
void lecture(void);
void comparer(void);
unsigned long int crypt(unsigned char k,unsigned long int n,unsigned long int e);
unsigned char decrypt( unsigned long int k,unsigned long int d,unsigned long int n);
void crypter(void);
void decrypter(void);
void inscri(void);
int p_e_e2(int x);
void pgcd2(int a,int b,int* taille,int* tab[]);
void decomp(int*s,int*q,int*r,int*k);
int cle_priv(int e,int z);
void pq(int* p,int* q);
void decomposition(void);

void main(void)
{
	printf("\n\n\n\n\n\n\n\n\t\t\t       CRYPTOGRAPHIE\n\n\n\n\n\n\n\n\n");
   printf("\n\n\t\t\t        version 1.0");
   getch();

   clrscr();

   menu();

   getch();
}

/****************************MENU PRINCIPAL************************************/

void menu(void)
{
	int choix=0;

   printf("\n\n\t\t\t       ****************\n");
   printf("\t\t\t       *MENU PRINCIPAL*\n");
	printf("\t\t\t       ****************\n\n\n\n");
   printf("\t   TAPEZ :\n\n\n\n");
   printf("\t\t1\t   POUR\t        UTILISER LA CRYPTOGRAPHIE\n\n");
   printf("\t\t2\t   POUR\t        REALISER DIVERS CALCULS\n\n");
   printf("\t\t3\t   POUR\t        QUITTER LE LOGICIEL\n\n\n");
   printf("\t   CHOIX : ");
   scanf("%d",&choix);

   switch(choix)
   {
   	case 1 : clrscr();
      			menu_crypto();
      break;

      case 2 : clrscr();
      			menu_calcul();
      break;

      case 3 : quitter();
      break;

      default : erreur();
   }
}


/***************************MENU CRYPTOGRAPHIE*********************************/

void menu_crypto(void)
{

	int choix=0;

 	printf("\n\n\t\t\t     ********************\n");
   printf("\t\t\t     *MENU CRYPTOGRAPHIE*\n");
	printf("\t\t\t     ********************\n\n\n\n");
   printf("\t   TAPEZ :\n\n\n\n");
   printf("\t\t1\t   POUR\t        VOUS INSCRIRE\n\n");
   printf("\t\t2\t   POUR\t        CRYPTER\n\n");
   printf("\t\t3\t   POUR\t        DECRYPTER\n\n");
   printf("\t\t4\t   POUR\t        LIRE UN FICHIER\n\n");
   printf("\t\t5\t   POUR\t        COMPARER 2 FICHIERS\n\n");
   printf("\t\t6\t   POUR\t        MENU PRECEDENT\n\n\n");
   printf("\t   CHOIX : ");
   scanf("%d",&choix);

   switch(choix)
   {
   	case 1 : inscri();
      break;

      case 2 : clrscr();
      			crypter();
               clrscr();
               choix_crypto();
      break;

      case 3 : clrscr();
      			decrypter();
               clrscr();
               choix_crypto();
      break;

      case 4 : clrscr();
      			lecture();
               clrscr();
               choix_crypto();
      break;

      case 5 : clrscr();
      			comparer();
               clrscr();
               choix_crypto();
      break;

      case 6 :  clrscr();
      			 menu();
      break;

      default : erreur();
   }
}


/*******************************CRYPTER****************************************/

void crypter(void)
{
	FILE *source_crypt;
	FILE *res_crypt;

	unsigned char c;
	unsigned long int i=0;
	unsigned long int k,n,e;
	char nom_fichier[20];

   printf("\n\n\t\t\t   	*********\n");
   printf("\t\t\t     	*CRYPTER*\n");
	printf("\t\t\t     	*********\n\n\n\n");

   fflush(stdin);

	printf("Donner le nom du fichier source avec son extension : ");
	gets(nom_fichier);

	printf("\n\n\n\tdonner votre cle publique n : ");
   scanf("%d",&n);

   printf("\n\n\n\tdonner votre cle publique e : ");
   scanf("%d",&e);

	source_crypt=fopen(nom_fichier,"rb");
	if(source_crypt==NULL)
	{
   	printf("Impossible d'ouvrir le fichier source.\n");
   }

	res_crypt=fopen("result.cry" , "wb");
	if(res_crypt==NULL)
	{
   	printf("Impossible d'ouvrir le fichier resultat.\n");
   }
   clrscr();
   printf("\n\n\t\tATTENDEZ SVP PENDANT LE CRYPTAGE.");

	while((feof(source_crypt)==0) && (fread(&c,sizeof(unsigned char),1,source_crypt)!=0))
  	{
  	   fseek(source_crypt,sizeof(unsigned char)*i,SEEK_SET);
     	fread(&c,sizeof(unsigned char),1,source_crypt);
   	k=crypt(c,n,e);
      fwrite(&k,sizeof(unsigned long int),1,res_crypt);
 		i=i+1;
   }

	fclose(source_crypt);
	fclose(res_crypt);
	printf("\n\n\n\n\n\n\n\n\n\nLe cryptage de votre fichier est termine.");
   printf("\n\nvotre fichier crypter se nomme result.cry");
	getch();

}

/******************************FONCTION CRYPTAGE*******************************/

unsigned long int crypt(unsigned char k,unsigned long int n,unsigned long int e)
{
	unsigned long int i,res=1,nbre;

	nbre=((unsigned long int)k);

	for(i=0;i<e;i++)
	{
    	res = res * nbre;
	 	res=fmod(res,n);
	}

	return res;

}

/*******************************DECRYPTER**************************************/

void decrypter(void)
{

	FILE *source;
   FILE *res_decrypt;
	char l;
   unsigned long int h=0;
	unsigned long int d,n;
   unsigned long int lect_int;
	char nom_fichier[20],nom_fin[20];

   printf("\n\n\t\t\t   	***********\n");
   printf("\t\t\t     	*DECRYPTER*\n");
	printf("\t\t\t        ***********\n\n\n\n");

   fflush(stdin);

	printf("Donner le nom du fichier avec son extension : ");
	gets(nom_fichier);

	printf("Donner le nom du fichier de destination avec son extension : ");
	gets(nom_fin);

	printf("\n\n\n\tdonner votre cle prive n : ");
   scanf("%d",&n);

   printf("\n\n\n\tdonner votre cle prive d : ");
   scanf("%d",&d);

	source=fopen(nom_fichier , "rb");
	if(source==NULL)
	{
   	printf("Impossible d'ouvrir le fichier a decrypter.\n");
      erreur();
   }

	res_decrypt=fopen(nom_fin , "wb");

	if(res_decrypt==NULL)
	{
   	printf("Impossible d'ouvrir le fichier resultat.\n");
      erreur();
   }
   clrscr();

   printf("\n\n\t\tATTENDEZ SVP PENDANT LE DECRYPTAGE.");

	while((feof(source)==0) && (fread(&lect_int,sizeof(unsigned long int),1,source)!=0))
	{
	   fseek(source,sizeof(unsigned long int)*h,SEEK_SET);
      fread(&lect_int,sizeof(unsigned long int),1,source);
      l=decrypt(lect_int,d,n);
      fwrite(&l,sizeof(unsigned char),1,res_decrypt);
      h=h+1;
   }

	fclose(source);
	fclose(res_decrypt);
	printf("\n\n\n\n\n\n\n\n\n\nLe decryptage de votre fichier est termine.");
   getch();
}


/****************************FONCTION DECRYPTAGE*******************************/

unsigned char decrypt(unsigned long int k,unsigned long int d,unsigned long int n)
{
	unsigned long int i,res=1;
	unsigned char x;

	for(i=0;i<d;i++)
	{
    	res=res*k;
      res=fmod(res,n);
	}

	x=((unsigned char)res);

	return x;
}

/********************************LECTURE***************************************/

void lecture(void)
{
	int compteur_car;
   int compteur_ligne;
   int car_lect;
   FILE *fichier;
   char nom_fichier[20];

   printf("\n\n\t\t\t**********************\n");
   printf("\t\t\t*LECTURE D'UN FICHIER*\n");
	printf("\t\t\t**********************\n\n\n");
   fflush(stdin);
   printf("Donner le nom du fichier a lire (avec son extension) : ");
   gets(nom_fichier);

   fichier=fopen(nom_fichier,"r");

   if(fichier==NULL)
   {
   	printf("\n\nImpossible d'ouvrir le fichier a lire.\n");
   }

   compteur_ligne=0;
   compteur_car=0;
if(fichier!=NULL){
   printf("\n\nLecture du fichier en cours.\n\n");

   while((car_lect = fgetc(fichier))!=EOF)
   {
   	compteur_car = compteur_car + 1;
      printf("%c",car_lect);

      if(compteur_car == 40)
      {
      	compteur_car = 0;
         compteur_ligne = compteur_ligne + 1;
      }

      if(compteur_ligne>=17)
      {
      	compteur_car = 0;
         compteur_ligne = 0;
         getch();
         clrscr();
      }
   }
   printf("\n\n\nLa lecture du fichier est terminee.");
   }
   fclose(fichier);
   getch();

}

/*******************************COMPARAISON************************************/

void comparer(void)
{
	int compt=0;

   int car_lect,car_lect2;
   FILE *fichier;
   FILE *fichier2;
   char nom_fichier[20];
   char nom_fichier2[20];

   printf("\n\n\t\t\t  ***************************\n");
   printf("\t\t\t  *COMPARAISON DE 2 FICHIERS*\n");
	printf("\t\t\t  ***************************\n\n\n");

   fflush(stdin);

   printf("Donner le nom du fichier source (avec son extension) : ");
   gets(nom_fichier);


   printf("Donner le nom du fichier a comparer (avec son extension) : ");
   gets(nom_fichier2);

   fichier=fopen(nom_fichier,"r");

   fichier2=fopen(nom_fichier2,"r");

   if(fichier==NULL)
   {
   	printf("\n\nImpossible d'ouvrir le fichier source.\n");
   }

   if(fichier2==NULL)
   {
   	printf("\n\nImpossible d'ouvrir le fichier a comparer.\n");
   }


if((fichier!=NULL) && (fichier2!=NULL))
	{
   printf("\n\nLecture des fichiers en cours.\n\n");

   while(((car_lect = fgetc(fichier))!=EOF)&&((car_lect2 = fgetc(fichier2))!=EOF))
   {
   	if(car_lect!=car_lect2)
   	{
         compt=compt+1;
      }
   }

   if(compt==0)
	{
      printf("\n\nLes deux fichiers sont identiques.");
   }

   else
	{
      printf("\n\nIl y a %d caracteres d'ecart.",compt);
   }
   }
   fclose(fichier);
   fclose(fichier2);

  	getch();
}


/******************************CHOIX CRYPTO************************************/

void choix_crypto(void)
{
	int choix;

   printf("\n\n\n\n\t   QUE SOUHAITEZ VOUS FAIRE ?\n\n\n\n\n");
   printf("\t   TAPEZ :\n\n\n");
   printf("\t\t1\t   POUR\t        REVENIR AU MENU PRINCIPAL\n\n");
   printf("\t\t2\t   POUR\t        REVENIR AU MENU CRYPTOGRAPHIE\n\n");
   printf("\t\t3\t   POUR\t        QUITTER LE LOGICIEL\n\n\n");
   printf("\t   CHOIX : ");
   scanf("%d",&choix);

   switch(choix)
   {
   	case 1 : clrscr();
      			menu();
      break;

      case 2 : clrscr();
      			menu_crypto();
      break;

      case 3 : quitter();
      break;

      default : erreur();
   }
}


/******************************MENU CALCUL*************************************/

void menu_calcul(void)
{
 	int choix=0;

 	printf("\n\t\t\t     *************\n");
   printf("\t\t\t     *MENU CALCUL*\n");
	printf("\t\t\t     *************\n\n\n");
   printf("\t   TAPEZ :\n\n\n\n");
   printf("\t\t1\t   POUR\t       CALCULER LE PGCD DE 2 NOMBRES\n\n");
   printf("\t\t2\t   POUR\t       DECOMPOSER UN NOMBRE EN NOMBRES PREMIERS\n\n");
   printf("\t\t3\t   POUR\t       CALCULER UN MODULO\n\n");
   printf("\t\t4\t   POUR\t       TESTER LA PRIMARITE D'UN NOMBRE\n\n");
   printf("\t\t5\t   POUR\t       VOIR SI 2 NOMBRES SONT PREMIERS ENTRE EUX\n");
   printf("\t\t6\t   POUR\t       MENU PRECEDENT\n\n\n");
   printf("\t   CHOIX : ");
   scanf("%d",&choix);

   switch(choix)
   {
   	case 1 : clrscr();
      			pgcd();
               clrscr();
               choix_calcul();
      break;

      case 2 : clrscr();
      			decomposition();
               clrscr();
               choix_calcul();

      break;

      case 3 : clrscr();
      			modulo();
               clrscr();
               choix_calcul();
      break;

      case 4 : clrscr();
      			primarite();
               clrscr();
               choix_calcul();
      break;

      case 5 : clrscr();
      			p_e_e();
               clrscr();
               choix_calcul();
      break;


      case 6 : clrscr();
      			menu();
      break;

      default : erreur();
   }
}

/*********************************CALCUL DU PGCD*******************************/

void pgcd(void)
{
	int a,b,*reste,*s,*q;

   reste=(int*)malloc(sizeof(int));  //initialisation de reste
   s=(int*)malloc(sizeof(int));  //initialisation de s
   q=(int*)malloc(sizeof(int));  //initialisation de q

   printf("\n\n\t\t\t     ****************\n");
   printf("\t\t\t     *CALCUL DU PGCD*\n");
	printf("\t\t\t     ****************\n\n\n");
   printf("Donner le 1er entier : ");
   scanf("%d",&a);
   printf("\nDonner le 2eme entier : ");
   scanf("%d",&b);

   *s=a;
   *q=b;

   *reste=fmod(*s,*q);

   while(*reste!=0 && *reste>0)
   {
   	*s=*q;
      *q=*reste;
      *reste=fmod(*s,*q);
   }
   printf("\nle PGCD de %d et %d est %d.",a,b,*q);
   getch();
}

/*********************************MODULO***************************************/

void modulo(void)
{
   int res,x,y;

   printf("\n\n\t\t\t    ******************\n");
   printf("\t\t\t    *CALCUL DU MODULO*\n");
	printf("\t\t\t    ******************\n\n\n");
   printf("\n\ncalcul de X modulo Y");
   printf("\n\nDonner X : ");
   scanf("%d",&x);

   printf("\n\nDonner Y : ");
   scanf("%d",&y);

   res=fmod(x,y);

   printf("\n\n%d modulo %d est egal a %d.",x,y,res);

   getch();
}

/*******************************PRIMARITE**************************************/


void primarite(void)
{
	int x,i,taille=0;

   printf("\n\n\t\t\t***********************\n");
   printf("\t\t\t*PRIMARITE D'UN NOMBRE*\n");
	printf("\t\t\t***********************\n\n\n");
   fflush(stdin);
   printf("Donner un entier : ");
   scanf("%d",&x);

   if(x==0 || x==1)
   {
   	printf("%d n'est pas premier.",x);
   }

   else
   {
   	for(i=2;i<x;i++)
   	{
      	if(x%i==0)
      	{
         	taille=taille+1;
      	}
   	}

   	if(taille==0)
   	{
   		printf("%d est premier.",x);
   	}

   	else
   	{
   		printf("%d n'est pas premier.",x);
   	}
   }
	getch();
}


/**************************PREMIERS ENTRE EUX**********************************/

void p_e_e(void)
{
	int a,b,*reste,*s,*q;

   reste=(int*)malloc(sizeof(int));  //initialisation de reste
   s=(int*)malloc(sizeof(int));  //initialisation de s
   q=(int*)malloc(sizeof(int));  //initialisation de q

   printf("\n\n\t\t\t   ********************\n");
   printf("\t\t\t   *PREMIERS ENTRE EUX*\n");
	printf("\t\t\t   ********************\n\n\n");
   printf("Donner le 1er entier : ");
   scanf("%d",&a);
   printf("\nDonner le 2eme entier : ");
   scanf("%d",&b);

   *s=a;
   *q=b;

   *reste=fmod(*s,*q);

   while(*reste!=0 && *reste>0)
   {
   	*s=*q;
      *q=*reste;
      *reste=fmod(*s,*q);
   }

   if(*q==1)
   {
   	printf("\n\n%d et %d sont premiers entre eux.",a,b);
   }

   else
   {
   	printf("\n\n%d et %d ne sont pas premiers entre eux.",a,b);
   }

   getch();
}


/****************************CHOIX CALCUL**************************************/

void choix_calcul(void)
{
	int choix;

   printf("\n\n\n\n\t   QUE SOUHAITEZ VOUS FAIRE ?\n\n\n\n\n");
   printf("\t   TAPEZ :\n\n\n");
   printf("\t\t1\t   POUR\t        REVENIR AU MENU PRINCIPAL\n\n");
   printf("\t\t2\t   POUR\t        REVENIR AU MENU DES CALCULS\n\n");
   printf("\t\t3\t   POUR\t        QUITTER LE LOGICIEL\n\n\n");
   printf("\t   CHOIX : ");
   scanf("%d",&choix);

   switch(choix)
   {
   	case 1 : clrscr();
      			menu();
      break;

      case 2 : clrscr();
      			menu_calcul();
      break;

      case 3 : quitter();
      break;

      default : erreur();
   }
}

/********************************ERREUR****************************************/

void erreur(void)
{
	int choix;

	printf("\nERREUR DE SAISIE.");

   getch();
   clrscr();

   printf("\n\n\n\n\t\tSOUHAITEZ VOUS REVENIR AU MENU PRINCIPAL ?\n\n\n\n\n");
   printf("\t   TAPEZ :\n\n\n");
   printf("\t\t1\t   POUR\t        REVENIR AU MENU PRINCIPAL\n\n");
   printf("\t\t2\t   POUR\t        QUITTER LE LOGICIEL\n\n\n");
   printf("\t   CHOIX : ");
   scanf("%d",&choix);

   switch(choix)
   {
   	case 1 : clrscr();
      			menu();
      break;

      case 2 : quitter();
      break;

      default : erreur();
   }
}


/***********************************inscription********************************/

 void inscri(void)
{
   int p,q,e,z,d,n;
   clrscr();
      printf("\n\n\t\t\t\t*************\n");
   printf("\t\t\t\t*INSCRIPTION*\n");
	printf("\t\t\t\t*************\n\n\n");

	pq(&p,&q);
   n=p*q;
   z=(p-1)*(q-1);
   e=p_e_e2(z);
   printf("\n\n\n\n\n\n\n\n\t( n : %d ; e : %d ) est votre cle publique.",n,e);
   d=cle_priv(e,z);
   printf("\n\n\n\n\t( n : %d ; d : %d ) est votre cle privee.",n,d);
   getch();
   getch();
   getch();
   clrscr();
   choix_crypto();

}

/******************************************************************************/

int p_e_e2(int x)
{
	int y,*tab[100000],*taille,rep,i;
   taille=(int*)malloc(sizeof(int));
   *taille=0;
   for(i=0;i<100000;i++)
   {
   	tab[i]=(int*)malloc(sizeof(int));
   }

   for(y=1;y<x;y++)
   {
   	pgcd2(x,y,taille,tab);
   }
   randomize();
	rep=*tab[rand()%*taille];
   return rep;
}
/******************************************************************************/
void pgcd2(int a,int b,int* taille,int* tab[])
{
int *reste,*k,*s,*q;
reste=(int*)malloc(sizeof(int));
k=(int*)malloc(sizeof(int));
s=(int*)malloc(sizeof(int));
q=(int*)malloc(sizeof(int));
*s=a;
*q=b;
*reste=1;
decomp(s,q,reste,k);
while(*reste!=0&&*reste>0)
               {
               *s=*q;
               *q=*reste;
               decomp(s,q,reste,k);
               }
if(*q==1)
{
   *tab[*taille]=b;
   *taille=*taille+1;
}
}


/******************************************************************************/
void decomp(int*s,int*q,int*r,int*k)
{


*k=0;
while(*s>=*q)
           {
           *s=*s-*q;
           *k=*k+1;
           }
*r=*s;
}

/******************************************************************************/

int cle_priv(int e,int z)
{
	int d,i=0;



   while((e*i)%z!=1)
   {
   	i=i+1;
   }

   d=i;
   return d;
}
/******************************************************************************/

void pq(int* p,int* q)
{
int t[200],i,y,j,taille=0;


   for (i=3;i<200;i++)
   			{ y=0;
             for(j=2;j<i;j++)
             			{
                     if(i%j==0)
                     			{
                              y=y+1;
                              }
                     }
             if(y==0)
             			{
                     //printf("   %d   ",i);
                     t[taille]= i;
                     taille=taille+1;
                     }
            }
randomize();
*p=t[rand()%taille];
*q=t[rand()%taille];

}


/*************************DECOMPOSITION****************************************/

void decomposition(void)
{
	int prem[100000],puissance[100000];
	int n,o,i,j,k,compt,taille=0;

   printf("\n\n\t\t     ***********************************\n");
   printf("\t\t     *DECOMPOSITION EN NOMBRES PREMIERS*\n");
	printf("\t\t     ***********************************\n\n\n");

   printf("\nDonner 1 entier : ");
	scanf("%d",&n);
   printf("\n\n");
   o=n;
   for(i=2;i<o+1;i++)
   {
    	compt=0;
      for(j=2;j<i;j++)
      {
        	if(i%j==0)
         {
           	compt=compt+1;
         }
      }

      if(compt==0)
      {
        	prem[taille]=i;
         taille=taille+1;
      }
   }

   for(i=0;i<taille;i++)
   {
   	k=0;
    	while(fmod(o,prem[i])==0)
      {
      	o=o/prem[i];
         k=k+1;
         puissance[i]=k;
      }
   }

   printf("%d =",n);

   for(i=0;i<taille;i++)
   {
    	if(puissance[i]!=0)
      {
      	printf(" (%d",prem[i]);
   		printf("^");
   		printf("%d)",puissance[i]);
      }
   }


   getch();
}


/******************************************************************************/


void quitter(void)
{
	clrscr();

   printf("\n\n\n\n\n\n\n\n\n");
   printf("       *     *   *	      ******   ****** *       * ****** * ******       \n");
   printf("      * *    *   *	      *    *   *       *     *  *    * * *    *       \n");
   printf("     *****   *   *            ******   ***      *   *   *    * * ******       \n");
   printf("    *     *  *   *	      *     *  *         * *    *    * * *     *      \n");
   printf("   *       * *****	      *      * ******     *     ****** * *      *     \n");

}


/*************************************END**************************************/

Sources du même auteur

MOTUS

COMPRESSION HUFFMAN

IO.SYS

CHEAT MODE POUR ALERT ROUGE 2

PIX ANIM

Toutes les sources de Kreator

Sources de la même categorie

PROJET DE CRYPTOGRAPHIE: RSA À JEU REDUIT D'INSTRUCTION par samatarahmed

CRYPTOSYSTÈME ELGAMAL LIBRAIRIE GMP par louelh95

NOUVEL ALGORITHME D'ENCRYPTION-DÉSENCRYPTION DYNAMIQUE (INFA... par vletktol

A2DCRYPT - CRYPTAGE 2048 BITS par darkor

CRYPTEUR-DÉCRYPTEUR-IP par antho974

Toutes les sources de la catégorie Sécurité & Cryptage

Commentaires et avis

Commentaire de mmuller57 le 29/01/2002 21:47:32

C'est cool le cryptage Rivest-Shamir-Adelman :)

Commentaire de psycho le 22/05/2002 01:10:33

c pas mal. On peut cependant gagner un peu de temps pour la primalité ( je ne sais pas si sa ce dit primarité, mais ne chipotons pas [8)] ), puisque la boucle que tu fais (for(i=2;i<x;i++)) est "bcp trop grande" : tu n as besoin d 'aller que jusqu à int(rac(x)) c a dire la valeur entiere de la racine carree de x...mais bon, en c++, on est plus à 3 ms près...
sinon, c un bon code.
voila....@+

Commentaire de Lion7 le 21/07/2002 23:24:59

Oui bon en etant objectif, c'est sur que de crypter sur un seul caractere n'est pas tres judicieux, quant a ta remarque Je, si tu veux je vais utiliser cet algo avec une cle de 1024 bits, j'espere que ton QI est superieur a 900-950, car tu vas enchainer les exposants ;-) Bon en etant plus serieux, Karma il te faut choisir un autre algo, car celui-ci n'est pas tres sur, sinon bon programme quand meme, ++

Commentaire de Galett le 01/10/2002 00:57:12

Lion7 : dis tu crois ke le nombre de neurones est lié linéairement au QI ?....*compte ses 3 neurones* mamann !!!!
oui bon sinon le code est facilement cassable, déja une solution serait de créer une classe GrandsEntiers pour pouvoir crypter sur autre chose que des char.
et aussi une méthode pour trouver de grands entiers premier est l'algo de Miller-Rabin (fais une recherche sur google), qui est certe probabiliste, mais le pourcentage d'erreur est tellement infime qu'il vaut le coup.(cet algo est utilisé ds l'industrie il me semble, donc y a pas de prob).
sinon pour infos, le cryptage RSA est considéré comme sûr (à l'heur actuelle) pour une clé avec environ 200 digits(chiffres), le problème, c'est qu'il est interdit pour des pauvres mortels tels ke nous(entendez des civils) de coder sur plus de 40 bits...(interdit de coder si le gouvernement ne peut pas le décrypter)
Mais bon déja sur 40 bits c bien suffisant.
(alors pkoi i.e est codé sur 128 bits ? tt simplement paske l' entreprise(M$) a demandé à pouvoir utiliser un codage plus sûr, spécial entreprise)
en résumé, pour être sûr et rester dans la légalité, le mieux c d'utiliser un programme autorisé à coder sur + de 40 bits.

Commentaire de Onishin le 14/12/2002 01:42:24

Sur quand theme de securite sa faut pas grand chose meme si on code avec un clefs de 111100000000bits
Pour la simple raison que lon code char par char
si on code avec une clef de 1024 on sous entend que l'on code par morceau de 1024 et non pas 8 car faire un simple supstitution de caractere pas de pb mais de morceau de phrase de 1024/8 char beaucoup plus dur!!!
sinon le code est tres tres bien pour voir comment sa marche le RSa

Commentaire de LordBob le 05/01/2003 02:48:03

oui ton code est tres bien, je compte m'en servir...

Commentaire de LordBob le 07/01/2003 22:19:58

dommage kil fonctionne sous TC++

Commentaire de Tesla93 le 08/04/2003 14:34:25

j'aimerai trouver une personne qui m'aide a crée un algorithme ou a crée un programme qui crypte a mort

un truc que le gouvernement se casse les dents a decrypter

merci d'avance si vous penser etre comme sa envoyer moi un message :)

Commentaire de fredoufredou le 07/05/2003 14:41:53

ouais gros t'es trop fort

Commentaire de AlexFlt le 30/12/2003 16:37:37

ben c'est pas dur du tout de trouver un truc qui ne sera pas decrypter avant quelque siecle utilise le DES (clef 56bits cryptage par bloc dee 64bits) il est utiliser dans les carte bancaire et normalement n'a pas encore ete casser sinon si tu es un peu parano utilise un IDEA (clef128bits block 64bits il existe une version 128 128 sa s'appelle CAST) la t tranquil perssonne ne le decodera sans la clef !!!! sinon dans les chiffrement en continu tu as A5,RC-5,SEAL ... et dans les chiffrement a clef publique : RSA est trés bien avec une clef de 1024 mais c'est un peu plus dur a realiser ( c'est tres ch*** les nb de 200 chiffres) !!!

Commentaire de Blawk le 28/01/2004 12:22:07

Remettons un peu les choses aux clair.
La legislation français autorise maintenant de clefs plus grande que 40 bits (128 je crois).

DES n'est plus utiliser nul part. Il peut être casser en très peu de temps avec des machines spécialisée mais néanmoins bon marché (pour une entreprise, un mafia... pas pour un particulier). Seul sa variante est utilisé: le Triple DES (TDES) qui utilise des clefs de 112 bits mais est trois fois plus lents. A court terme, ce chiffre est suffisamment sûr.

Aujourd'hui, le standard cryptographique est AES. Il crypte par bloc de 16octets (on peut le faire crypter avec des blocs plus grand mais ce n'est plus standard et accessoirement moins beau) avec des clef de 128bits extensible à n'importe quel multiple de 32.

Pour l'instant, aucune attaque autre que la recherche exaustive des clef n'a été trouvée. AES procure donc une sécurité assez durablement infaillible pour des clef d'au moins 128bits.

Pour ceux que ça interesse, l'implantation est assez aisée (je l'ai faite sans trop de problèmes) et la doc abondante.

Commentaire de sitesref le 02/05/2004 12:24:57

petit détail amusant: dans mon pays (la Belgique) y'a pas de limites de cryptage je crois on peut faire 4096 si on veut (mais bon le problème réside en le fait qu'il faut faire l'algo et ça c'est coton à faire)

Moralité -> Venez habiter chez nous, y'a pas de sarkozy ! :-D

Commentaire de StanOfSky le 04/05/2004 00:46:06

sympas ta source
mais bon pas tres lisible
petits conseils ;) :
* sépare entrées (clavier), sortie (affichage), fonctions mathématiques
non seulement ce sera bcp plus lisible mais en plus réutilisable facilement
* plus de commentaires ;) mais bon de tte maniere le RSA si on n'a pas fait d'arithmétique et étudié un peu le sujet c assez compliqué à assimilé

sinon chu un peu decu, je m'attendai à une implémentation d'une classe gérant de grand nombres...parce que c vrai que sur un octet c un peu dérisoire comme cryptage
autant utilisé du XOR bcp plus simple à implémenter et plus sur que ton code ;)

bonne continuation

Commentaire de StanOfSky le 04/05/2004 00:49:52

créer un nouvel algo de cryptage n'est pas donné à tout le monde surtt s'il faut qu'il fonctionne avec clefs publiques et privées.

sinon le AES, il aurait été cassé... http://www.yacapa.com/article-822.html (à vérifier)

Commentaire de Patalou le 16/05/2004 00:23:03

Il existe une méthode qui ne permet pas de retrouver le message, c'est soit faire une clef aussi longue que le message, soit, méthode que j'ai essayé, mettre cacher le message dans un fichier bien plus gros tel qu'une image. Méthode utilisée par certains setsirortes pour dialoguer sans être vus.
Je ne suis pas spécialiste de cryptologie, je peux me tromper mais je ne crois pas.
Le moins est qu'il faut transporter une clef aussi grosse que le message.

Commentaire de Super_Mat le 19/09/2004 14:24:50

Faire une clef aussi longue que les données à protéger, ca s'appelle un masque jetable je crois.

C'est incassable si la clef n'est utilisée qu'une seule fois. Evidemment, c'est hyper lourd à utiliser.

Le "téléphone rouge" qui est en fait un télex (au dernière nouvelles) utilise des masques jetables qui ont étés échangés par valises diplomatiques.

L'idée de cacher l'info dans une image est un peu différente, puisque la protection vient du fait que Charlie ne sait pas qu'il y a quelque chose d'important dans l'image. Ou plus exactement, il se doute qu'une des images est suspectes, mais on n'a ni le temps ni les moyens de passer au cribles toutes les images qui passent par mail, par exemple.

On ne se rend compte de rien en voyant l'image car se sont les bits de poids faibles qui sont remplacés par ceux des données.

En plus on peut chiffrer les données avant de les cacher ... ca complique encore les choses.

Commentaire de BesoinDaides le 04/01/2005 20:22:23

Bonjour à tous!

Je voulais juste dire que je ne comprends rien aux codages R.S.A. malgré que l'on met expliqué plusieurs fois.En gros j' aimerai avoir de l' aide s' il vous plaît.

En attente d' une réponse,je vous remercie d' avance,

Commentaire de Super_Mat le 04/01/2005 21:00:03

En gros, le RSA veut qu'on puisse échanger un message secrètement, sans qu'on se soit mis d'accord au préalable sur un mot de passe. Cela permet de communiquer secrètement avec un canal peu sûr.

La technique consiste à créer deux clefs par personne : une privée et une publique. Les clefs sont des nombres grands, et la protection du message vient du fait qu'on ne sache pas retrouver la pair de clef à partir de messages chiffrés.

La clef publique est donnée à qui veut l'avoir (elle peut même est diffusée sur Internet). La clef privée elle doit rester secrète.

Si A veut envoyer un message à B, A chiffre son message grâce à la clef publique de B (que tout le monde peut avoir). Mais toute la subtilité c'est qu'on ne déchiffre pas le message avec la clef publique (sinon il n'y a aucune protection ;-)) mais avec la clef publique.

C'est pour ca qu'on dit du RSA qu'il est à clefs asymétriques : une pour chiffrer, une autre pour déchiffrer.

Concrétement, c'est plus difficile d'expliquer simplement l'implémentation de RSA. Disons que la difficulté réside dans le fait qu'à partir de a,b deux nombres premiers, il est très facile de faire a*b.

Par contre, en connaissant a*b, il est très difficile de retrouver a et b. Exemple facile : a = 3 et b = 97. On voit 3*97 = 291 mais c'est difficile de dire que 291 = 3*9.

Dans la pratique, on prend a et b grand pour que ca soit difficile.

J'espère t'avoir aidé.

Commentaire de belghit11 le 14/03/2005 21:49:55

est ce que je peu utiliser ce code avec c++builder pour
avoir une interface graphique avec deux boutons crypter et decrypter? et merci bq

Commentaire de Stepharcher le 14/09/2005 20:43:20

la fonction de cryptage est trop longue si la clé publique est grande à cause de la boucle... ;) Tu devrais utiliser les puissances pour remédier au problème.

Commentaire de genomind le 15/09/2005 00:27:23

Belghit11 > je ne sais, j'ai fait ce prog sous borland C++, en projet avec des potes de l'iut, ça fait un moment.

Stepharcher > en fait j'ai fait un autre prog de crypto que je m'apprête à poster qui utilise la méthode du XOR, plus rapide, mais le seul problème, c'est que ce n'est pas compressable.

Commentaire de nesrounatn le 16/03/2006 09:14:44

je voudrais programmer ce code en flash action script s'il vous plais
Merci....

Commentaire de picouf le 05/04/2006 19:09:47

Bonjour,

Je suis nouveau sur ce site et n'y connait rien au language C.
J'aimerai utiliser ce programme mais je ne sais pas avec quel programme le compiler, ni quelle est la démarche à suivre une fois qu'on a le programme pour compiler.

Pouvez vous me dire comment faire, merci (j'utilise windows)
Merci

Commentaire de Dragozor le 04/04/2011 01:51:42 5/10

Inutile de réinventer la roue, utilisez la bibliothèque RSA en C++ http://www.jeux-libres.com/tutoriaux/tuto-423-cryptage-rsa-en.php

Ajouter un commentaire

Nos sponsors

Derniers Blogs

CSS CONTENT STATE SELECTORS (PERSONNAL DRAFT) par FREMYCOMPANY

MBA : POURQUOI FAIRE ET COMMENT LE CHOISIR ? par ROMELARD Fabrice

Y'A DES ERREURS QUI PEUVENT RENDRE LE DéVELOPPEUR VIOLENT par Aleks

[HYPER-V 3] PRéSENTATION DES COMMANDLETS POWERSHELL par Pierrick CATRO-BROUILLET

IIS7 - COMPRESSION GZIP par cyril

Forum

RE : CRéATION D'UN AGENDA éLECTRONIQUE par taghssa

RE : [QT]JEUX SIMILAIRE à ZELDA EN MULTIJOUEUR par Neckara

AIDE PROBLEM DE COMPILATION par pboscaiolo

ARBRE BINAIRE par pacotheking

RE : RéCUPéRER UN CHAMP D'UN QTABLEVIEW DANS UN QLINEEDIT par mature

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Cherche referenceur astucieux
Budget : 1 500€
Recherche expert advisor sous mql4 hedging
Budget : 200€
Creation boutique en ligne iphone- android - Republication.
Budget : 4 000€

Logiciels

Easy-Planning (1.0.0.1)
EASY-PLANNING (1.0.0.1)

Basé sur les mêmes principes que MyPlanning, Easy-Planning permet de créer des plannings sous la ...

Cliquez pour télécharger Easy-Planning
Academy System (17.1.3.0)
ACADEMY SYSTEM (17.1.3.0)

Logiciel de gestion des établissements. - élèves/étudiants (inscription, dossier, absence...) -...

Cliquez pour télécharger Academy System
COLLECTOR PLUS (3.00B)
COLLECTOR PLUS (3.00B)

COLLECTOR PLUS version 3.00B est un logiciel utilisant une base de données alimentée par : - L...

Cliquez pour télécharger COLLECTOR PLUS
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)

PONAMEDIA TV DEVIENS HELLLOOO FLASH LA TV SUR VOTRE ORDINATEUR. Toute une plateforme Multi...

Cliquez pour télécharger PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO
LettresFaciles 2011 (8.0.0.1)
LETTRESFACILES 2011 (8.0.0.1)

LettresFaciles est un logiciel facilitant la création et la rédaction de lettres types. Son inte...

Cliquez pour télécharger LettresFaciles 2011