CRYPTAGE RC5 32/12/16

#include <windows.h>
/*----------------------------------------------------------------------*/
/* RC5REF.C  -- Reference implementation of RC5-32/12/16 in C    		*/
/* Copyright © 1995 RSA Data security. Inc.                             */
/*----------------------------------------------------------------------*/
/* les fonctions crypte et decrypte utilisent les algorithmes de cyptage*/
/* définis dans ce document de référence.								*/
/* 		RC5_SETUP: extension de la clé passée en argument sous forme de	*/
/*			chaine de caractères. Si l'appel de crypte ou decrypte ne 	*/
/*			ne comporte pas de cle ("") c'est la cle précdémment		*/
/*			traitée qui est utilisée									*/
/*			s'il n' y a pas de texte à crypter la fonction crypte ou 	*/
/*			decrypte se contente de réaliser l'expansion de la clé		*/
/*		RC5_ENCRYPT: cryptage d'un double mot							*/
/*		RC5_DECRYPT: decryptage d'un double mot							*/
/*	dans cette implémentation, on fixe les paramétres de cryptage		*/
/*		taille du mot: 32 bits											*/
/*		nombre d'itérations: 12											*/
/*		taille (maxi) de clé en octets: 16								*/
/*		(paramètres nominaux choisis par Ronald L. Rivest)				*/
/*																		*/
/*----------------------------------------------------------------------*/
/* crypte et decrypte travaillent sur des textes de longueur variable	*/
/* alloués par le module appelant.										*/
/* le résultat du cryptage est codé sous la forme d'une chaine de 		*/
/* caractères sur 7 bits (pour rester dans le jeu standard ASCII)		*/
/* et supérieurs à 48 (pour éviter les codes non éditables et blancs)	*/
/* la taille à allouer pour la chaine cryptée doit être au moins de 	*/
/* 5 fois le nombre de groupes de 4 caractères dans le texte à crypter	*/

/* typedef unsigned long int WORD ;  	/* should be 32 bits = 4 bytes	*/
/* on modifie à cause de win.h qui définit WORD sur 16 bits				*/
typedef unsigned int W32;
# define w		32		/*  word size in bits					*/
# define r		12		/* number of rounds						*/
# define b		16		/* number of bytes in key				*/
# define c		4		/* number of words in key				*/
						/* c =max(1,ceil(8*b/w)					*/
# define t		26		/* size of table S =2*(r+1) words		*/
W32 S[t] ;				/* expanded key table					*/
W32 pt[2],ct[2];		/* pour le passage des deux mots		*/
W32 P = 0xb7e15163, Q = 0x9e3779b9;	/* magic constants		*/
int FlCle =0;

/* Rotation operators, x must be unsigned, to get logical right shift		*/
# define ROTL(x,y)	(((x) << (y & (w-1))) | ((x) >>(w-(y&(w-1)))))
# define ROTR(x,y)	(((x) >> (y & (w-1))) | ((x) <<(w-(y&(w-1)))))

BOOL WINAPI __declspec(dllexport) LibMain(HINSTANCE hDLLInst, DWORD fdwReason, LPVOID lpvReserved)
{
	/* traitement des événements liés au chargement/déchargement			*/
/*  	 switch (fdwReason)
	    {
    	    case DLL_PROCESS_ATTACH:
			etc...
	    }
*/
    return TRUE;
}
/* fonction de cryptage, sur 2 mots binaires en entrée et en sortie			*/
void RC5_ENCRYPT( W32 *pt, W32 *ct)
{ W32 i , A= pt[0] + S[0] , B= pt[1] + S[1] ;
	for  (i=1 ; i<=r ; i++ )
	{	A = ROTL ( A^B,B) + S[2*i] ;
		B = ROTL ( B^A,A) + S[2*i+1] ;
	}
	ct[0]= A ; ct[1]= B ;
}
/* fonction de décryptage, sur 2 mots binaires en entrée et en sortie		*/
void RC5_DECRYPT( W32 *ct, W32 *pt)
{ W32 i , B= ct[1] , A= ct[0] ;
	for  (i=r ; i>0 ; i-- )
	{	B = ROTR (B - S[2*i+1], A) ^ A ;
		A = ROTR (A - S[2*i], B) ^ B ;
	}
	pt[1]= B - S[1] ; pt[0]= A - S[0] ;
}
/* fonction d'installation de la clé étendue								*/
void RC5_SETUP(unsigned char *K)
{ W32 i, j, k, u=w/8, A, B, L[c] ;
int lc;
	/* initialize L, then S, then mix key into S */
	lc=strlen(K);
	if (lc>b) lc=b;

	for (i=b-1, L[c-1]=0 ; i != -1 ; i--) {
		if (i>=lc)
			{ L[i/u] = (L[i/u] << 8) + 0 ;}
		else
			{ L[i/u] = (L[i/u] << 8) + K[i] ;}
	}
	for (S[0]=P, i=1 ; i<t ; i++ ) S[i] = S[i-1] + Q ;
	for (A=B=i=j=k=0 ; k< 3*t ; k++, i =(i+1)%t, j =(j+1)%c )	/* 3*t > 3*c	*/
	{ 	A = S[i] = ROTL ( S[i] + (A + B) ,3) ;
		B = L[j] = ROTL ( L[j] + (A + B), (A + B)) ;
	}
	FlCle=1;
}
/* fonction exportée pour le cryptage de PText, vers CText, selon Clé...			*/
BOOL WINAPI __declspec(dllexport) crypte(char *PText, char *CText, char *Cle)
{
/* fontion de cryptage																*/
/*		le programme passe la chaine à crypter, et une adresse pour le résultat		*/
/* 		si une cle est passée, on fait le SETUP. Sinon on utilise la cle stockée	*/
	int lt;					/* longueur de la chaine en octets						*/
	int ipt=0;				/* indice du caractère courant dans le texte en entrée	*/
	int ict=0;				/* indice du caractère courant dans la chaine en sortie	*/
	int i;
	unsigned char *sw;		/* pointeur de caractères de travail 					*/
	int cx;					/* octet de report pour le codage du résultat			*/

	/* Mise en place de la cle si elle est donnée									*/
	if (strlen(Cle)>0) RC5_SETUP(Cle);
	/* sinon on travaillera avec la cle courante, si elle existe					*/
	if (FlCle ==0 ) return FALSE;

	/* taille du texte à crypter*/
	lt=strlen(PText);

	/* on travaille par groupes de 8 octets	pour le cryptage						*/
	while (ipt<lt) {

		/* valeur à crypter*/
		/* transfert des octets sur l'adresse du tableau d'entiers pt...			*/
		sw= (unsigned char *)pt;
		for (i=0;i<8;i++) {
			if (ipt>=lt) sw[i]=0;
			else sw[i]=PText[ipt];
			ipt++;
		}

		/* cryptage dans ct */
		RC5_ENCRYPT(pt,ct);

		/* report dans la chaine résultat sous forme de caractères éditables		*/
		/* chaque groupe de 4 octets est complété par un octet de report			*/
		/* pour chaque caractère on prend les 7 bits de poids faible, 				*/
		/* et on rajoute 48 si nécessaire (pour éviter les codes de controle ASCII)	*/
		/* on stocke l'info dans les 2 bits correspondants dans l'octet de report	*/
		sw=(unsigned char *)ct;
		cx=0;
		for (i=0;i<8;i++) {
			/* on prend les 7 bits de droite */
			CText[ict]=sw[i] & 0x7F;
			/* on stocke le bit de gauche dans le bit 1 de l'octet de report		*/
			cx=cx+((sw[i] & 0x80)>>6);
			/* si le caractère est non imprimable on rajoute 48 et on marque  		*/
			/* le bit 0 de l'octet de report, pus on décale de 2					*/
			if (CText[ict]<48) { CText[ict]+=48; cx=cx+1;}

			ict++;

			if ((i==3) || (i==7)) {
				/* rajout de l'octet de report										*/
				CText[ict]=cx;
				ict++;cx=0;
			}
			else {
				cx=cx<<2;				/* on décale de 2 bits l'octet de report	*/
			}
		}
	}
	CText[ict]=0;

	return TRUE;
}
/* fonction exportée pour le décryptage de PText, vers CText, selon Clé...			*/
BOOL WINAPI __declspec(dllexport) decrypte(char *CText, char *PText,char *Cle)
{
/* fontion de décryptage															*/
/*		le programme passe la chaine à décrypter, et une adresse pour le résultat	*/
/* 		si une cle est passée, on fait le SETUP. Sinon on utilise la cle stockée	*/

	int lc;					/* longueur de la chaine cryptée en octets				*/
	int ipt=0;				/* indice du caractère courant dans le texte en entrée	*/
	int ict=0;				/* indice du caractère courant dans la chaine en sortie	*/
	int i,j;
	int x=0;
	unsigned char xv;		/* octet de report pour le décodage						*/
	unsigned char *sw;		/* pointeur de caractères de travail 					*/

	/* Mise en place de la cle si elle est donnée									*/
	if (strlen(Cle)>0) RC5_SETUP(Cle);
	/* sinon on travaillera avec la cle courante, si elle existe					*/
	if (FlCle ==0 ) return FALSE;

	lc=strlen(CText);

	/* on travaille par groupes de 10 octets (2* (4+1) )			 				*/
	/* ict est l'offset du début de groupe dans la chaine							*/
	while (ict<lc) {

		/* valeur à décrypter*/
		/* décodage de la chaine CText vers l'adresse du tableau d'entiers ct...	*/
		/* chaque groupe de 5 de caractères est traansformé en un entier			*/
		/* boucle sur le nombre de double-mots (10 octets à chaque fois)			*/

		/* pour remplir les entiers ct[] octet par octet on s'appuie sur un ptr sw	*/
		sw= (unsigned char *)ct;

		/* première phase: on prend tels quels les octets. 							*/
		/* On traitera ensuite les octets de contrôle								*/
		j=0;
		for (i=0;i<10;i++) {
			if ((i!=4) && (i!=9)) {
				/* on prend l' octet tel quel */
				sw[j]=CText[ict+i];
				/* l'indice j permet d'avancer en sautant les octets de contrôle	*/
				j++;
			}
		}

		/* traitement du premier octet de report 									*/
		xv=CText[ict+4];
		/* les couples de bits sont traités de droite à gauche						*/
		/* on traite un par un et on décale au fur et à mesure						*/
		for (i=3;i>=0;i--) {
			/* bit de droite pour enlever 48 	*/
			x=xv & 1;
			if (x==1) sw[i]=sw[i]-48;
			xv=xv>>1;
			/* nouveau but de droite: reporté en poids fort 						*/
			x=xv & 1;
			if (x==1) sw[i]=sw[i] | 0x80;
			xv=xv>>1;
		}
		/* deuxième octet de controle: même chose 									*/
		xv=CText[ict+9];
		for (i=7;i>=4;i--) {
			/* bit de droite pour enlever 48	*/
			x=xv & 1;
			if (x==1) sw[i]=sw[i]-48;
			xv=xv>>1;
			/* nouveau but de droite: reporté en poids fort 						*/
			x=xv & 1;
			if (x==1) sw[i]=sw[i] | 0x80;
			xv=xv>>1;
		}

		/* saut vers le prochain groupe de 10 octets								*/
		ict+=10;

		/* decryptage dans pt */
		RC5_DECRYPT(ct,pt);

		/* report dans la chaine de départ, octet par octet							*/
		/* ipt est l'offset courant du groupe de 8 caractères dans la chaine PText	*/
		sw=(unsigned char *)pt;
		for (i=0;i<8;i++) {
			PText[ipt]=sw[i];
			ipt++;
		}
	}
	PText[ipt]=0;

	return TRUE;
}
unsigned long WINAPI __declspec(dllexport) teste( int i, int j)
{
		if (i==0) return pt[j];
		if (i==1) return ct[j];
		return 0;
}