Rc6

Algorithme utilisé par Up ! Security Manager

L'algorithme Arc Six (RC6) du laboratoire Rsa crypte un flux binaire à partir d'une clé CleInitiale de taille TailleCle qui est au plus 256 octets et d'un nombre d'itérations compris entre 1 et 255.

Dans un premier temps, la clé est expansée de la sorte à atteindre 2*NbIterations+4 octets.

Dans un second temps, le flux est crypté par bloc de seize octets en réalisant des opérations sur leurs bits avec la clé expansée.

Il existe différentes variantes :

RC6.
Le flux binaire doit être obligatoirement composé d'un multiple de seize octets et pré-découpé.
RC6-CBC.
Le flux binaire doit être obligatoirement composé d'un multiple de seize octets et il est découpé en blocs au fil de l'eau.
RC6-CBC-PAD.
Le flux binaire est d'une taille quelconque. Le dernier bloc incomplet est complété ou un bloc supplémentaire est rempli avec un octet dont la valeur est le nombre d'octets de remplissage ajouté - 16-TailleFlux%16.
RC6-CTS.
Le flux binaire est d'une taille quelconque. Le dernier bloc incomplet est complété avec l'octet 0.

Contexte

L'algorithme de cryptage / décryptage utilise un contexte composé des constantes et des variables globales suivantes :

Constante /*******/


	RC6_W=32;

	RC6_WW=8;

	RC6_ROT_MASK=31;

	RC6_BB=16;

	RC6_P=0xb7e15163;

	RC6_Q=0x9e3779b9;




Variable

/******/


	S : Tableau[?] De Nul Ou Octet;

	VecteurInitialisation : Tableau[8] De Nul Ou Octet;

	BlocDEntree : Tableau[8] De Nul Ou Octet;

	BlocChaine : Tableau[8] De Nul Ou Octet;

	IndexBlocDEntree : Entier;

	IndexBlocChaine : Entier;

Expansion de la clé

Voici l'algorithme d'expansion de la clé :

Variable /******/


	I : Entier;

	J : Entier;

	K : Entier;

	LL : Entier;

	L : Tableau[32] De Nul Ou Entier;

	T : Entier;

	A : Entier;

	B : Entier;




Debut

T=2*NbIterations+4;

S=TableauDe(0,T-1,Octet(0));

LL=(TailleCle+7)/8);

Pour I=0 JusquA TailleCle-1 Faire


   T=(CleInitiale[I]&0xFF)<<(8*(I%4));

   L[I/8]=L[I/8]+T;


Fin Pour

S[0]=RC6_P;

Pour I=1 JusquA T-1 Faire


   S[I]=S[I-1]+CO_RC6_Q;


Fin Pour

I=0;

I=0;

A=0;

B=0;

Si LL>T Alors

   K=3*LL;


Sinon

   K=3*T;


Fin Si

TantQue K>0 Faire

   A=RotationGauche(S[I]+A+B,3,CO_RC6_W);

   S[I]=A;

   B=RotationGauche(L[J]+A+B,A+B,CO_RC6_W);

   L[J]=B;

   I=((I+1)%T);

   J=((J+1)%LL);


Fin Pour

Cryptage RC6 d'un bloc de seize octets


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

Fonction RotationGauche(X : Entier, N : Entier)

/* Objet : Effectue un rotation gauche de N bits.               */

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

Debut

Retourner (X<<N)|(X>>(32-N));

Fin Fonction



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

Procedure Crypter(BufferEntree : Binaire, BufferSortie : Binaire)

/* Objet : Crypte un binaire de 8 octets.                       */

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

Variable

/******/


	I : Entier;

	A : Entier;

	B : Entier;

	C : Entier;

	D : Entier;

	E : Entier;

	T : Entier;

	U : Entier;




Debut

A=BufferEntree[0]+(BufferEntree[1]<<8)+(BufferEntree[2]<<16)+(BufferEntree[3]<<24);

B=BufferEntree[4]+(BufferEntree[5]<<8)+(BufferEntree[6]<<16)+(BufferEntree[7]<<24);

C=BufferEntree[8]+(BufferEntree[9]<<8)+(BufferEntree[10]<<16)+(BufferEntree[11]<<24);

D=BufferEntree[12]+(BufferEntree[13]<<8)+(BufferEntree[14]<<16)+(BufferEntree[15]<<24);

B+=S[0];

D+=S[1];

Pour I=1 JusquA NbIterations Faire


   T=DecalageGauche(B*(2*B+1),5);

   U=DecalageGauche(D*(2*D+1),5);

	A=A^T;

   A=DecalageGauche(A,U,32)+S[2*I];

   C=B^U;

   C=DecalageGauche(B,T,32)+S[(2*I)+1];


Fin Pour

A+=S[2*NbIterations+2];

C+=S[2*NbIterations+3];

BufferSortie[0]=A&0xFF;

BufferSortie[1]=(A>>8)&0xFF;

BufferSortie[2]=(A>>16)&0xFF;

BufferSortie[3]=(A>>24)&0xFF;

BufferSortie[4]=B&0xFF;

BufferSortie[5]=(B>>8)&0xFF;

BufferSortie[6]=(B>>16)&0xFF;

BufferSortie[7]=(B>>24)&0xFF;

BufferSortie[8]=C&0xFF;

BufferSortie[9]=(C>>8)&0xFF;

BufferSortie[10]=(C>>16)&0xFF;

BufferSortie[11]=(C>>24)&0xFF;

BufferSortie[12]=D&0xFF;

BufferSortie[13]=(D>>8)&0xFF;

BufferSortie[14]=(D>>16)&0xFF;

BufferSortie[15]=(D>>24)&0xFF;

Fin Procedure

Decryptage RC6 d'un bloc de huit octets


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

Fonction RotationDroite(X : Entier, N : Entier)

/* Objet : Effectue un rotation droite de N bits.               */

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

Debut

Retourner (X>>N)|(X<<(32-N));

Fin Fonction



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

Procedure Decrypter(BufferEntree : Binaire, BufferSortie : Binaire)

/* Objet : Decrypte un binaire de 8 octets.                     */

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

Variable

/******/


	I : Entier;

	A : Entier;

	B : Entier;

	C : Entier;

	D : Entier;

	E : Entier;

	T : Entier;

	U : Entier;




Debut

A=BufferEntree[0]+(BufferEntree[1]<<8)+(BufferEntree[2]<<16)+(BufferEntree[3]<<24);

B=BufferEntree[4]+(BufferEntree[5]<<8)+(BufferEntree[6]<<16)+(BufferEntree[7]<<24);

C=BufferEntree[8]+(BufferEntree[9]<<8)+(BufferEntree[10]<<16)+(BufferEntree[11]<<24);

D=BufferEntree[12]+(BufferEntree[13]<<8)+(BufferEntree[14]<<16)+(BufferEntree[15]<<24);

C=C-CleExpansee[2*NbIterations+3]);

A=A-CleExpansee[2*NbIterations+2]);

Pour I=NbIterations JusquA 1 Pas -1 Faire


   U=DecalageAGauche(D*(2*D+1),5);

   T=DecalageAGauche(B*(2*B+1),5);

   C=DecalageGauche(C-CleExpansee[(2*I)+1],T);

   C=(CO_RC6_WORD)(C^U);

   A=DecalageGauche(A-CleExpansee[2*I],U);

   A=(CO_RC6_WORD)(A^T);


Fin Pour

D-=D[1];

B-=B[0];

BufferSortie[0]=A&0xFF;

BufferSortie[1]=(A>>8)&0xFF;

BufferSortie[2]=(A>>16)&0xFF;

BufferSortie[3]=(A>>24)&0xFF;

BufferSortie[4]=B&0xFF;

BufferSortie[5]=(B>>8)&0xFF;

BufferSortie[6]=(B>>16)&0xFF;

BufferSortie[7]=(B>>24)&0xFF;

BufferSortie[8]=C&0xFF;

BufferSortie[9]=(C>>8)&0xFF;

BufferSortie[10]=(C>>16)&0xFF;

BufferSortie[11]=(C>>24)&0xFF;

BufferSortie[12]=D&0xFF;

BufferSortie[13]=(D>>8)&0xFF;

BufferSortie[14]=(D>>16)&0xFF;

BufferSortie[15]=(D>>24)&0xFF;

Fin Procedure