implémentation de DIFFIE-HELLMAN

Bonsoir à tous,
Je voudrais soumettre un petit bout de code pour avoir votre avis sur
mon implementation ainsi que pour savoir si l'implementation vous semble
suffisament sure.

Dans mon code j'ai tenté de résoudre le problème lié aux grands nombres.
Pour memoire la methode est la suivante :

A et B souhaitent s'echanges des données
A génére un nombre x et calcule X = (g^x) modulo p
B génére un nombre y et calcule Y = (g^y) modulo p
A et B s'echyangent leur X et Y respectifs
et calculent k = (X^y)modulo p = (Y^x) modulo p

J'ai donc procedé par génération de n k de petite taille (3 bit) affin
de pouvoir calculer leur puissance à l'interieur d'un entier.
chaque k est par la suite ramené à 2 bit K%4 afin de constituer des
blocs de 2 bits.

Si vous avez comprit, ceci signifie que pour une clef d'echange K de
longeur 56 bits (DES) il me faut générer 28 clefs k

Voici le code, je vous prie de ne pas tenir compte :
- Du random, j'ai pris ici le bête random du c
- De l'affichage un peut ésothérique

Merci de vos commentaires.
- Fato
fatoReMoVeThIs@free.fr
fatoAefFaCeR@free.fr

/**********************************************************************/
#include <memory.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <math.h>


#define g 7
#define n 5
#define KEYLEN 28



int BuildMatrix()
{


unsigned int X,Y,x,y;
int c;

int Matrixx[KEYLEN];
int MatrixX[KEYLEN];
int Matrixy[KEYLEN];
int MatrixY[KEYLEN];
int MatrixK[KEYLEN];

x = 0;

// Clear the buffers
//******************
memset((void *)&Matrixx,0,KEYLEN);
memset((void *)&MatrixX,0,KEYLEN);
memset((void *)&Matrixy,0,KEYLEN);
memset((void *)&MatrixY,0,KEYLEN);
memset((void *)&MatrixK,0,KEYLEN);

// Generate the x,y,X,Y matrix
//*****************************
for(c = 0;c<KEYLEN;c++)
{

// Take x and y 2 random numbers between 0 and 12
//*************************************************
x = rand()%12;
y = rand()%12;

// Calculate X and Y
//********************************
X = ((unsigned int)pow(g,x))%n;
Y = ((unsigned int)pow(g,y))%n;

// Fill the matrix
//******************
Matrixx[c] = x;
MatrixX[c] = X;
Matrixy[c] = y;
MatrixY[c] = Y;

// Calculate the shared key matrix
//*************************************
MatrixK[c] = ((unsigned int)pow(Y,x))%n;
}

// DISPLAY THE X KEY MATRIX
//********************************
printf("\n X = 0x");
for(c = 1;c<KEYLEN;c++)
{
x = MatrixX[c];
printf("%0X",x);
}
printf("\n Y = 0x");

// DISPLAY THE Y KEY MATRIX
//********************************
for(c = 1;c<KEYLEN;c = c++)
{
x = MatrixY[c];
printf("%0X",x);
}
printf("\n K = 0x");

// DISPLAY THE COMPUTED EXCHANGE KEY
//************************************************
for(c = 1;c<KEYLEN;c = c+2)
{
x = (MatrixK[c]%4) + ((MatrixK[c-1]%4)<<2);
printf("%X",x);
}
printf("\n");
return 0;
}



int main()
{
int ct = 0;
srand( (unsigned)time( NULL ) );

while(getc(stdin) != 'q')
{
BuildMatrix();
printf("\nPress 'q' to quit or another key to continue :");
}

return 0;
}