Fonction de definitions de clées rsa 22 bits fonctions de cryptage/décryptage

Commenter

Contenu du snippet

Ce source permet de générer de manière aléatoire des clées publiques et privées
Ainsi que de crypter et de décrypter des trames.
Il est un peu lent pour le moment mais j'y travaille...
Les critiques sont les bien venues.

Source / Exemple : 


typedef struct
{
	unsigned __int64 N;
	unsigned __int64 E;
	unsigned __int64 D;
}TYP_RSA;

CInternCrypt::CInternCrypt()
{
	TYP_RSA Key;
	GetRandomKey(&Key);

	char Toto[80];	// Attention peut être alimenté après son strlen dans la fct encrypt
	UINT Lg = sprintf(Toto,"Essai de cryptage par RSA version SLX 123456");
	unsigned long Start = time(NULL);
	Encrypt(Toto,&Lg,Key.E,Key.N);
	unsigned long EncryptTime = time(NULL) - Start;
	Sleep(1);	// Juste mis un break point pour verifier

	Start = time(NULL);
	Decrypt(Toto,&Lg,Key.D,Key.N);
	unsigned long DecryptTime = time(NULL) - Start;
	Sleep(1);	// Juste mis un break point pour verifier
}

CInternCrypt::~CInternCrypt()
{
}

void CInternCrypt::GetRandomKey(TYP_RSA *Key)
{
	unsigned __int64 TabTmp[563];
	unsigned __int64 Cur = 1;
	unsigned __int64 Nbr = 0;
	memset(TabTmp,0,sizeof(TabTmp));
	do
	{
		BOOL Valid = TRUE;
		Cur += 2;
		for(unsigned __int64 i=0;i<Nbr && Valid;i++)
		{
			if((Cur % TabTmp[i]) == 0)
			{
				Valid = FALSE;	// Divisable par un premier déjà ds le tableau
			}
		}
		if(Valid)
		{
			TabTmp[Nbr] = Cur;	// C'est un nombre premier
			Nbr++;
		}
	}
	while(Nbr < 563);

	srand( (unsigned)time( NULL ) );
	unsigned __int64 P = TabTmp[408 + (rand() % 155)];
	unsigned __int64 Q;
	while((Q = TabTmp[408 + (rand() % 155)]) == P);

	unsigned __int64 Euler = (P-1)*(Q-1);
	Key->D = 17;							// Clé privée
	while((Euler % Key->D) == 0)
	{
		Key->D+=2;
	}
	Key->N = P * Q;							// le bigame !!!!
	unsigned __int64 k=0;
	do
	{
		k++;
		Key->E = ((1+(k*Euler))/Key->D) ;	// Determiner clé publique
	}
	while(k < Euler && (((1+(k*Euler))%Key->D) !=0));
}

void CInternCrypt::Encrypt(char *Trame,UINT *Len,unsigned __int64 E,unsigned  __int64 N)
{
union
{
	unsigned __int64	Num;
	unsigned char		Alpha[8];	// 8 chars pour être = à la taille d' __int64
}Work;
char	Tmp[1024];

	while((*Len % 3) != 0)	// On ajuste à un multiple de 3 octets (24 bits)
	{


    		
  • Len = *Len + 1;

		Trame[*Len] = 0;
	}
	for(UINT i = 0;i<*Len;i+=3)
	{
		Work.Num = 0;
		memcpy(&Work.Alpha[0],&Trame[i],3);
		unsigned __int64 Cry	= 1; 
		for(unsigned __int64 j=0;j<E;j++)
		{
			Cry *= Work.Num;
			Cry = Cry%N;
			if(Cry >= 0xFFFFFF)	// C'est quoi tout ces bits en trop !!!
			{
				Sleep(1);		// ALLERRRRTTTTTT
			}
		}
		Work.Num = Cry;
		memcpy(&Tmp[i],&Work.Alpha[0],3);
	}
	memcpy(&Trame[0],&Tmp[0],*Len);
}

void CInternCrypt::Decrypt(char *Trame, UINT *Len, unsigned __int64 D, unsigned __int64 N)
{	// Il y a du copié collé dans l'air...
union
{
	unsigned __int64	Num;
	unsigned char		Alpha[8];
}Work;
char	Tmp[1024];

	while((*Len % 3) != 0)
	{


    		
  • Len = *Len + 1;

		Trame[*Len] = 0;
	}
	for(UINT i = 0;i<*Len;i+=3)
	{
		Work.Num = 0;
		memcpy(&Work.Alpha[0],&Trame[i],3);
		unsigned __int64 Cry	= 1; 
		for(unsigned __int64 j=0;j<D;j++)
		{
			Cry *= Work.Num;
			Cry = Cry%N;
			if(Cry >= 0xFFFFFF)
			{
				Sleep(1); // ALLERRRRTTTTTT
			}
		}
		Work.Num = Cry;
		memcpy(&Tmp[i],&Work.Alpha[0],3);
	}
	memcpy(&Trame[0],&Tmp[0],*Len);
}

Conclusion :


Comme dit plus haut, le cryptage est trop lent, il faut que je m'y mette.

A voir également

S'inscrire maintenant

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.