Rc2

Algorithme utilisé par Up ! Security Manager

L'algorithme Arc Two (RC2) de l'Internet Engineering Task Force (IETF) crypte un flux binaire à partir d'une clé CleInitiale de taille TailleCle qui est au plus 128 octets.

Dans un premier temps, la clé est expansée de la sorte à atteindre 128 octets et seuls NbBits bits dits significatifs sont conservés.

Dans un second temps, le flux est crypté par paquet de huit octets à partir deux fonctions de base Mixer et Ecraser réalisant des opérations sur les bits des octets du paquet avec la clé expansée.

Expansion de la clé

L'algorithme d'expansion de la clé utilise une table constante composées de 256 octets correspondant aux décimales de Pi :

Variable /******/


	TablePi : Tableau[256] De Nul Ou Octet;




TablePiRc2=
 

  {

  217,120,249,196, 25,221,181,237, 40,233,253,121, 74,160,216,157, 

  198,126, 55,131, 43,118, 83,142, 98, 76,100,136, 68,139,251,162, 

   23,154, 89,245,135,179, 79, 19, 97, 69,109,141,  9,129,125, 50, 

  189,143, 64,235,134,183,123, 11,240,149, 33, 34, 92,107, 78,130, 

   84,214,101,147,206, 96,178, 28,115, 86,192, 20,167,140,241,220, 

   18,117,202, 31, 59,190,228,209, 66, 61,212, 48,163, 60,182, 38, 

  111,191, 14,218, 70,105,  7, 87, 39,242, 29,155,188,148, 67,  3, 

  248, 17,199,246,144,239, 62,231,  6,195,213, 47,200,102, 30,215, 

    8,232,234,222,128, 82,238,247,132,170,114,172, 53, 77,106, 42, 

  150, 26,210,113, 90, 21, 73,116, 75,159,208, 94,  4, 24,164,236, 

  194,224, 65,110, 15, 81,203,204, 36,145,175, 80,161,244,112, 57, 

  153,124, 58,133, 35,184,180,122,252,  2, 54, 91, 37, 85,151, 49, 

   45, 93,250,152,227,138,146,174,  5,223, 41, 16,103,108,186,201, 

  211,  0,230,207,225,158,168, 44, 99, 22,  1, 63, 88,226,137,169, 

   13, 56, 52, 27,171, 51,255,176,187, 72, 12, 95,185,177,205, 46, 

  197,243,219, 71,229,165,156,119, 10,166, 32,104,254,127,193,173 

  };

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

Variable /******/


	CleExpansee : Tableau[128] De Nul Ou Entier;

	I : Entier;

	T8 : Octet;

	TM : Octet;




Debut

Pour I=0 JusquA TailleCle-1 Faire


   CleExpansee[i]=Cle[i];


Fin Pour

T8=(NbBits+7)/8;

TM=255%2^(8+NbBits-8*T8);

Pour I=TailleCle JusquA 127 Faire


   CleExpansee[i]=TablePi[(CleExpansee[i-1]+CleExpansee[i-NbBits])&0xFF];


Fin Pour

CleExpansee[128-T8]=TablePi[CleExpansee[128-T8]&TM];

Pour I=127-T8 JusquA 0 Faire


   CleExpansee[i]=TablePi[(CleExpansee[i+1]^CleExpansee[i+T8])&0xFF];


Fin Pour

Fonctions Mixer et Ecraser

Les fonctions Mixer et Ecraser utilisent un table de constantes TableRotations :

Variable /******/


	TableRotations : Tableau[4] De Nul Ou Entier;




TableRotations=


  {

  1,2,3,5
 
  };

Voici les algorithmes des fonctions Mixer et Ecraser :

/****************************************************************/ Fonction Rotation(X:Entier, N:Entier) Retourner Entier /* Objet : X <<< N. */ /****************************************************************/ Debut Retourner (X<<N)|(X>>(16-N)); Fin Fonction /****************************************************************/ Procedure Mixer(Cle : Binaire, R : Tableau[4] De Nul Ou Octet, I0 : Entier, J : Entier Sortie) /* Objet : Mixe le buffer avec la cle pour Rc2. */ /****************************************************************/ Variable /******/


	I1 : Entier;

	I2 : Entier;

	I3 : Entier;




Debut

I1=(I0-1+4)%4;

I2=(I0-2+4)%4;

I3=(I0-3+4)%4;

R[I0]=R[I0]+Cle[J]+(R[I1]&R[I2])+((~R[I1])&R[I3]));

J++;

R[I0]=Rotation(R[I0],TableRotations[I0]);

Fin Procedure



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

Procedure Ecraser(Cle : Binaire, R : Tableau[4] De Nul Ou Octet, I0 : Entier)

/* Objet : Ecrase le buffer avec la cle pour Rc2.               */

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

Variable

/******/


	I1 : Entier;




Debut

R[I0]=R[I0]+Cle[R[I1]&63];
Fin Procedure

Cryptage d'un bloc de huits octets


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

Procedure Crypter(Cle : Binaire, B : Binaire)

/* Objet : Crypte le buffer avec la cle.                        */

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

Variable

/******/


	R : Tableau[4] De Nul Ou Entier;

	I : Entier;

	J : Entier;




Debut

Pour I=0 JusquA 3 Faire


	R[i]=B[2*I]+256*B[2*I+1];

Fin Pour

J=0;

Pour I=0 JusquA 4 Faire


   Mixer(Cle,R,0,J);
   Mixer(Cle,R,1,J);
   Mixer(Cle,R,2,J);
   Mixer(Cle,R,3,J);

Fin Pour

Ecraser(Cle,R,0);
Ecraser(Cle,R,1);
Ecraser(Cle,R,2);
Ecraser(Cle,R,3);
Pour I=0 JusquA 5 Faire


   MixerRc2(Cle,R,0,J);
   MixerRc2(Cle,R,1,J);
   MixerRc2(Cle,R,2,J);
   MixerRc2(Cle,R,3,J);

Fin Pour

EcraserRc2(Cle,R,0);
EcraserRc2(Cle,R,1);
EcraserRc2(Cle,R,2);
EcraserRc2(Cle,R,3);
Pour I=0 JusquA 4 Faire


   MixerRc2(Cle,R,0,J);
   MixerRc2(Cle,R,1,J);
   MixerRc2(Cle,R,2,J);
   MixerRc2(Cle,R,3,J);

Fin Pour

Pour I=0 JusquA 3 Faire


	B[2*I]=R[i]&0xFF;
	B[2*I+1]=(R[i]>>8)&0xFF;

Fin Pour

Fin Procedure

Décryptage d'un bloc de huits octets


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

Procedure Derypter(Cle : Binaire, B : Binaire)

/* Objet : Decrypte le buffer avec la cle.                      */

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

Variable

/******/


	R : Tableau[4] De Nul Ou Entier;

	I : Entier;

	J : Entier;




Debut

Pour I=0 JusquA 3 Faire


	R[i]=B[2*I]+256*B[2*I+1];

Fin Pour

J=63;

Pour I=0 JusquA 4 Faire


   Mixer(Cle,R,0,J);
   Mixer(Cle,R,1,J);
   Mixer(Cle,R,2,J);
   Mixer(Cle,R,3,J);

Fin Pour

Ecraser(Cle,R,0);
Ecraser(Cle,R,1);
Ecraser(Cle,R,2);
Ecraser(Cle,R,3);
Pour I=0 JusquA 5 Faire


   MixerRc2(Cle,R,0,J);
   MixerRc2(Cle,R,1,J);
   MixerRc2(Cle,R,2,J);
   MixerRc2(Cle,R,3,J);

Fin Pour

EcraserRc2(Cle,R,0);
EcraserRc2(Cle,R,1);
EcraserRc2(Cle,R,2);
EcraserRc2(Cle,R,3);
Pour I=0 JusquA 4 Faire


   MixerRc2(Cle,R,0,J);
   MixerRc2(Cle,R,1,J);
   MixerRc2(Cle,R,2,J);
   MixerRc2(Cle,R,3,J);

Fin Pour

Pour I=0 JusquA 3 Faire


	B[2*I]=R[i]&0xFF;
	B[2*I+1]=(R[i]>>8)&0xFF;

Fin Pour

Fin Procedure