Elgamalcipher
Description
Ce programme est une implémentation du chiffrement asymétrique publié par Taher ElGamal en 1985.
Cette implémentation chiffre des fichiers en générant des clef.
Pour utiliser le programme (ligne de commande, pas d'interface graphique), utiliser l'aide "elgamal -h".
Cette implémentation utilise la librairie GMP (http://gmplib.org/)
L'algorithme d'elgamal repose sur le problème des logarithmes discrets. Une fonction de cryptanalyse naïve est fournie par cette implémentation.
Cette implémentation chiffre des fichiers en générant des clef.
Pour utiliser le programme (ligne de commande, pas d'interface graphique), utiliser l'aide "elgamal -h".
Cette implémentation utilise la librairie GMP (http://gmplib.org/)
Source / Exemple :
#include <stdio.h>
#include <stdlib.h>
#include <gmp.h>
#include <math.h>
#include <string.h>
#include <time.h>
#define TAILLE_MESSAGE 50
#define PMIN "99999"
void genererClef(mpz_t ,mpz_t ,mpz_t ,mpz_t);
void effacerClef(mpz_t ,mpz_t ,mpz_t ,mpz_t);
void trouverGenerateur(mpz_t,mpz_t);
void chiffrer(char *,mpz_t ,mpz_t ,mpz_t);
void dechiffrer(char *,char *);
void genererFichierDesClefsPrivees(char *,mpz_t ,mpz_t,mpz_t);
void genererFichierDesClefsPubliques(char *,mpz_t ,mpz_t,mpz_t);
void getBlocMessage(mpz_t,FILE *,unsigned long int);
void generationClefEph(mpz_t,mpz_t);
void recupererClefPublique(char *,mpz_t ,mpz_t,mpz_t);
void cryptanalyser(char *,mpz_t );
unsigned long int getTailleOptimale(FILE *,mpz_t );
int main(int argc, char **argv)
{
if(strcmp(argv[1],"-d")==0)
{
dechiffrer(argv[2],argv[3]);
}
else{
if(strcmp(argv[1],"-k")==0)
{
mpz_t p,g,Y;
recupererClefPublique(argv[3],p,Y,g);
chiffrer(argv[2],p,g,Y);
}else{
if(strcmp(argv[1],"-h")==0)
{
printf("\n @$!_______________________@$!\n | ElGamalEncryptionByCHAR |\n @$!_______________________@$!\n\nUtilisation:\n\n elgamal cheminVersClair\nChiffre un message en générant une paire de clef\n\n elgamal -k cheminVersClair cheminVersClefPublique\nChiffre un message en utilisant une clef spécifié\n\n elgamal -d cheminVersMessage cheminVersClefPrivee\nDechiffre un message\n\n elgamal -c cheminVersFichierDeDéfinitionDeClefsPublique\nTente une cryptanalyse sur le fichier de clefs publiques spécifié\n");
}else{
if(strcmp(argv[1],"-c")==0)
{
mpz_t x;
cryptanalyser(argv[2],x);
mpz_clear(x);
}else{
mpz_t p,g,Y,x;
genererClef(p,g,Y,x);
gmp_printf("\nAffichage de la génaration des clefs\np=%Zd\ng=%Zd\nY=%Zd\nx=%Zd\n------\n",p,g,Y,x);
genererFichierDesClefsPrivees(argv[1],p,x,g);
genererFichierDesClefsPubliques(argv[1],p,Y,g);
chiffrer(argv[1],p,g,Y);
}
}
}
}
return EXIT_SUCCESS;
}
void trouverGenerateur(mpz_t g,mpz_t p)
{
mpz_t pm1,pm1sqrt,a,temp,temp2;
mpz_init(pm1);
mpz_init(pm1sqrt);
mpz_init(a); /*Initialisation, a=0*/
mpz_init(temp); /*Initialisation, temp = 0*/
mpz_init(temp2); /*Initialisation, temp2 = 0*/
mpz_set_ui(g,2); /*Initialisation, g=2*/
mpz_sub_ui(pm1,p,1); /*Initialisation, pm1= p - 1*/
mpz_root(pm1sqrt,pm1,2);
mpz_add_ui(pm1sqrt,pm1sqrt,1); /*Initialisation, pm1sqrt = (p - 1)^{1/2} + 1 */
gmp_printf("\npm1sqrt : %Zd\ng : %Zd",pm1sqrt,g);
/*On recherche tout les facteurs premiers de pm1*/
while(mpz_cmp(pm1sqrt,a)>0)
{
mpz_nextprime(a,a); /*Assignation de a au nombre premier suivant sa précédente valeur*/
mpz_powm_ui(temp,pm1,1,a); /*Assignation, temp = (p-1) mod a*/
if(mpz_cmp_ui(temp,0)==0)/*Dans ce cas, a divise pm1*/
{
mpz_divexact(temp,pm1,a); /*Assignation, temp = (p-1) / a*/
mpz_powm(temp2,g,temp,p); /* Assignation, temp2 = g^{(p-1)/a} mod (p)*/
mpz_set(temp,temp2);
if(mpz_cmp_ui(temp,(unsigned int)1)==0) /*Si g^{(p-1)/a} = 1 mod p*/
{
/*Changement du générateur*/
mpz_add_ui(g,g,1);
/*Redémarrage des a, diviseurs premiers de p-1*/
mpz_init(a);
}
}
}
mpz_clear(pm1);
mpz_clear(temp);
mpz_clear(a);
mpz_clear(pm1sqrt);
}
void genererClef(mpz_t p,mpz_t g,mpz_t Y,mpz_t x)
{
mpz_init(p);
mpz_init(g);
mpz_init(Y);
mpz_init(x);
mpz_set_str(p,PMIN,(int)10);
mpz_nextprime(p,p);
trouverGenerateur(g,p);
generationClefEph(x,p);
mpz_powm(Y,g,x,p);
}
void chiffrer(char *message,mpz_t p,mpz_t g,mpz_t Y)
{
/*Initialisations*/
mpz_t m,c1,c2,temp,Ke;
unsigned long int tailleBlocs;
FILE *fichierACrypter=NULL;
FILE *fichierCrypte=NULL;
mpz_init(m);
mpz_init(c1);
mpz_init(c2);
mpz_init(Ke);
mpz_init(temp);
/*Ouverture du fichier à crypter en lecture seule*/
fichierACrypter = fopen(message,"r");
/*Récupération de la longueur optimale des blocs*/
tailleBlocs = getTailleOptimale(fichierACrypter,p);
fichierACrypter = fopen(message,"r");
if(fichierACrypter == NULL)
{
printf("\n\n______________________________\nLe fichier n'a pas pu être chargé______________________________\n\n");
}else{
/*Création du fichier crypté en écriture effacement*/
strcat(message,".elGamal");
fichierCrypte = fopen(message,"w+");
/*Création de l'en-tête du fichier */
fprintf(fichierCrypte,"ElGamalEncryptionByCHAR:BT=%lu\n",(long unsigned int)1);
getBlocMessage(m,fichierACrypter,1);
do{
/*Génération de la clef éphémère*/
generationClefEph(Ke,p);
/* Chiffrement du bloc: assignation de c1 et c2*/
gmp_printf("chiffrement commencé\n c1: %Zd\nc2: %Zd\nm: %Zd\n",c1,c2,m);
mpz_powm(c1,g,Ke,p);
mpz_powm(temp,Y,Ke,p);
mpz_mul(temp,temp,m);
mpz_powm_ui(c2,temp,1,p);
gmp_printf("chiffrement effectué\nc1: %Zd\nc2: %Zd\nm: %Zd\n",c1,c2,m);
/* Ecriture des données chiffrées */
gmp_fprintf(fichierCrypte,"c1=%Zdc2=%Zd\n",c1,c2);
/*récupération d'une partie du message*/
getBlocMessage(m,fichierACrypter,1);
}while(mpz_cmp_ui(m,0)!=0);
/*Tests
mpz_t x;
mpz_init(x);
mpz_set_ui(x,100);
dechiffrer(message,c1,c2,p,x);
mpz_clear(x);
- /
Conclusion :
L'algorithme d'elgamal repose sur le problème des logarithmes discrets. Une fonction de cryptanalyse naïve est fournie par cette implémentation.
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.