Ripe Md 128

Algorithme utilisé par Up ! Security Manager

L'algorithme Ripe Md 128 (RipeMd128) de l'université du Rhin a pour principe de calculer une signature sur 16 octets d'un flux binaire ou texte.

Cette signature permet par exemple d'attester l'intégrité du contenu d'un fichier, d'un enregistrement d'une base de données, d'un message échangé, etc. parce qu'il est pratiquement impossible que deux contenus distincts produisent la même signature.

Ainsi :

Si les signatures sont différentes alors les contenus sont différents.
Si les contenus sont identiques alors les signatures sont identiques.
Si les contenus sont différents alors les signatures sont très certainement différentes.

Le principe est de calculer la valeur de quatre registres conserves dans le tableau TableRegistres dont les valeurs changent par application d'opérations paramétrées par leurs valeurs précédentes et le contenu du flux.

Voici l'algorithme RipeMd128 :

Initialisation.
Variable /******/ TableRegistres : Tableau[4] De Nul Ou Entier; TableRegistres[0]=0x67452301; TableRegistres[1]=0xefcdab89; TableRegistres[2]=0x98badcfe; TableRegistres[3]=0x10325476;
Pour chaque tranche de 16 octets du flux à signer :
La variable X contient la tranche des 16 octets du contenu à signer.
- Copie des registres dans une mémoire de travail.
  Variable /******/ AA : Entier; BB : Entier; CC : Entier; DD : Entier; AAA : Entier; BBB : Entier; CCC : Entier; DDD : Entier; AA=TableRegistres[0]; BB=TableRegistres[1]; CC=TableRegistres[2]; DD=TableRegistres[3]; AAA=TableRegistres[0]; BBB=TableRegistres[1]; CCC=TableRegistres[2]; DDD=TableRegistres[3];
- Opération FF.
  Application de l'opération FF présentée ci-après :
  FF(AA, BB, CC, DD, X[ 0], 11); FF(DD, AA, BB, CC, X[ 1], 14); FF(CC, DD, AA, BB, X[ 2], 15); FF(BB, CC, DD, AA, X[ 3], 12); FF(AA, BB, CC, DD, X[ 4], 5); FF(DD, AA, BB, CC, X[ 5], 8); FF(CC, DD, AA, BB, X[ 6], 7); FF(BB, CC, DD, AA, X[ 7], 9); FF(AA, BB, CC, DD, X[ 8], 11); FF(DD, AA, BB, CC, X[ 9], 13); FF(CC, DD, AA, BB, X[10], 14); FF(BB, CC, DD, AA, X[11], 15); FF(AA, BB, CC, DD, X[12], 6); FF(DD, AA, BB, CC, X[13], 7); FF(CC, DD, AA, BB, X[14], 9); FF(BB, CC, DD, AA, X[15], 8);
- Opération GG.
  Application de l'opération GG présentée ci-après :
  GG(AA, BB, CC, DD, X[ 7], 7); GG(DD, AA, BB, CC, X[ 4], 6); GG(CC, DD, AA, BB, X[13], 8); GG(BB, CC, DD, AA, X[ 1], 13); GG(AA, BB, CC, DD, X[10], 11); GG(DD, AA, BB, CC, X[ 6], 9); GG(CC, DD, AA, BB, X[15], 7); GG(BB, CC, DD, AA, X[ 3], 15); GG(AA, BB, CC, DD, X[12], 7); GG(DD, AA, BB, CC, X[ 0], 12); GG(CC, DD, AA, BB, X[ 9], 15); GG(BB, CC, DD, AA, X[ 5], 9); GG(AA, BB, CC, DD, X[ 2], 11); GG(DD, AA, BB, CC, X[14], 7); GG(CC, DD, AA, BB, X[11], 13); GG(BB, CC, DD, AA, X[ 8], 12);
- Opération HH.
  Application de l'opération HH présentée ci-après :
  HH(AA, BB, CC, DD, X[ 3], 11); HH(DD, AA, BB, CC, X[10], 13); HH(CC, DD, AA, BB, X[14], 6); HH(BB, CC, DD, AA, X[ 4], 7); HH(AA, BB, CC, DD, X[ 9], 14); HH(DD, AA, BB, CC, X[15], 9); HH(CC, DD, AA, BB, X[ 8], 13); HH(BB, CC, DD, AA, X[ 1], 15); HH(AA, BB, CC, DD, X[ 2], 14); HH(DD, AA, BB, CC, X[ 7], 8); HH(CC, DD, AA, BB, X[ 0], 13); HH(BB, CC, DD, AA, X[ 6], 6); HH(AA, BB, CC, DD, X[13], 5); HH(DD, AA, BB, CC, X[11], 12); HH(CC, DD, AA, BB, X[ 5], 7); HH(BB, CC, DD, AA, X[12], 5);
- Opération II.
  Application de l'opération II présentée ci-après :
  II(AA, BB, CC, DD, X[ 1], 11); II(DD, AA, BB, CC, X[ 9], 12); II(CC, DD, AA, BB, X[11], 14); II(BB, CC, DD, AA, X[10], 15); II(AA, BB, CC, DD, X[ 0], 14); II(DD, AA, BB, CC, X[ 8], 15); II(CC, DD, AA, BB, X[12], 9); II(BB, CC, DD, AA, X[ 4], 8); II(AA, BB, CC, DD, X[13], 9); II(DD, AA, BB, CC, X[ 3], 14); II(CC, DD, AA, BB, X[ 7], 5); II(BB, CC, DD, AA, X[15], 6); II(AA, BB, CC, DD, X[14], 8); II(DD, AA, BB, CC, X[ 5], 6); II(CC, DD, AA, BB, X[ 6], 5); II(BB, CC, DD, AA, X[ 2], 12);
- Opération III.
  Application de l'opération III présentée ci-après :
  III(AAA, BBB, CCC, DDD, X[ 5], 8); III(DDD, AAA, BBB, CCC, X[14], 9); III(CCC, DDD, AAA, BBB, X[ 7], 9); III(BBB, CCC, DDD, AAA, X[ 0], 11); III(AAA, BBB, CCC, DDD, X[ 9], 13); III(DDD, AAA, BBB, CCC, X[ 2], 15); III(CCC, DDD, AAA, BBB, X[11], 15); III(BBB, CCC, DDD, AAA, X[ 4], 5); III(AAA, BBB, CCC, DDD, X[13], 7); III(DDD, AAA, BBB, CCC, X[ 6], 7); III(CCC, DDD, AAA, BBB, X[15], 8); III(BBB, CCC, DDD, AAA, X[ 8], 11); III(AAA, BBB, CCC, DDD, X[ 1], 14); III(DDD, AAA, BBB, CCC, X[10], 14); III(CCC, DDD, AAA, BBB, X[ 3], 12); III(BBB, CCC, DDD, AAA, X[12], 6);
- Opération HHH.
  Application de l'opération HHH présentée ci-après :
  HHH(AAA, BBB, CCC, DDD, X[ 6], 9); HHH(DDD, AAA, BBB, CCC, X[11], 13); HHH(CCC, DDD, AAA, BBB, X[ 3], 15); HHH(BBB, CCC, DDD, AAA, X[ 7], 7); HHH(AAA, BBB, CCC, DDD, X[ 0], 12); HHH(DDD, AAA, BBB, CCC, X[13], 8); HHH(CCC, DDD, AAA, BBB, X[ 5], 9); HHH(BBB, CCC, DDD, AAA, X[10], 11); HHH(AAA, BBB, CCC, DDD, X[14], 7); HHH(DDD, AAA, BBB, CCC, X[15], 7); HHH(CCC, DDD, AAA, BBB, X[ 8], 12); HHH(BBB, CCC, DDD, AAA, X[12], 7); HHH(AAA, BBB, CCC, DDD, X[ 4], 6); HHH(DDD, AAA, BBB, CCC, X[ 9], 15); HHH(CCC, DDD, AAA, BBB, X[ 1], 13); HHH(BBB, CCC, DDD, AAA, X[ 2], 11);
- Opération GGG.
  Application de l'opération GGG présentée ci-après :
  GGG(AAA, BBB, CCC, DDD, X[15], 9); GGG(DDD, AAA, BBB, CCC, X[ 5], 7); GGG(CCC, DDD, AAA, BBB, X[ 1], 15); GGG(BBB, CCC, DDD, AAA, X[ 3], 11); GGG(AAA, BBB, CCC, DDD, X[ 7], 8); GGG(DDD, AAA, BBB, CCC, X[14], 6); GGG(CCC, DDD, AAA, BBB, X[ 6], 6); GGG(BBB, CCC, DDD, AAA, X[ 9], 14); GGG(AAA, BBB, CCC, DDD, X[11], 12); GGG(DDD, AAA, BBB, CCC, X[ 8], 13); GGG(CCC, DDD, AAA, BBB, X[12], 5); GGG(BBB, CCC, DDD, AAA, X[ 2], 14); GGG(AAA, BBB, CCC, DDD, X[10], 13); GGG(DDD, AAA, BBB, CCC, X[ 0], 13); GGG(CCC, DDD, AAA, BBB, X[ 4], 7); GGG(BBB, CCC, DDD, AAA, X[13], 5);
- Opération FFF.
  Application de l'opération FFF présentée ci-après :
  FFF(AAA, BBB, CCC, DDD, X[ 8], 15); FFF(DDD, AAA, BBB, CCC, X[ 6], 5); FFF(CCC, DDD, AAA, BBB, X[ 4], 8); FFF(BBB, CCC, DDD, AAA, X[ 1], 11); FFF(AAA, BBB, CCC, DDD, X[ 3], 14); FFF(DDD, AAA, BBB, CCC, X[11], 14); FFF(CCC, DDD, AAA, BBB, X[15], 6); FFF(BBB, CCC, DDD, AAA, X[ 0], 14); FFF(AAA, BBB, CCC, DDD, X[ 5], 6); FFF(DDD, AAA, BBB, CCC, X[12], 9); FFF(CCC, DDD, AAA, BBB, X[ 2], 12); FFF(BBB, CCC, DDD, AAA, X[13], 9); FFF(AAA, BBB, CCC, DDD, X[ 9], 12); FFF(DDD, AAA, BBB, CCC, X[ 7], 5); FFF(CCC, DDD, AAA, BBB, X[10], 15); FFF(BBB, CCC, DDD, AAA, X[14], 8);
- Composition des résultats.
  DDD+=CC+TableRegistres[1]; TableRegistres[1]=TableRegistres[2]+DD+AAA; TableRegistres[2]=TableRegistres[3]+AA+BBB); TableRegistres[3]=TableRegistres[0]+BB+CCC; TableRegistres[0]=DDD;
Terminaison.
La signature est composée des octets de TableRegistres[0], TableRegistres[1], TableRegistres[2], TableRegistres[3].

Le flux est toujours prolongé de la sorte que sa taille soit toujours un multiple de 16 octets :

Le premier octet de la prologation est toujours 0x80.
Les suivants sont 0x00.
Les 8 derniers sont toujours la taille initiale du flux en nombre de bits, dans l'ordre poids faible puis poids fort.
Si un bloc n'est pas suffisant pour ajouter à la fois l'octet 0x80 et la taille, un nouveau est ajouté.

Les registres TableRegistres[0], TableRegistres[1], TableRegistres[2], TableRegistres[3] sont encodés obligatoirement dans l'ordre poids faible puis poids fort.

Opérations

La variable T contient la table sinusoïdale discrète.

/****************************************************************/ Fonction RotationGauche(X:Entier, N:Entier) Retourner Entier /* Objet : Decalage a gauche de N bits. */ /****************************************************************/ Debut Retourner X<< Fin Fonction /****************************************************************/ Fonction F(X:Entier, Y:Entier, Z:Entier) Retourner Entier /* Objet : Operation F. */ /****************************************************************/ Debut Retourner X^Y^Z; Fin Fonction /****************************************************************/ Fonction G(X:Entier, Y:Entier, Z:Entier) Retourner Entier /* Objet : Operation G. */ /****************************************************************/ Debut Retourner (X&Y)|((~X)&,Z); Fin Fonction /****************************************************************/ Fonction H(X:Entier, Y:Entier, Z:Entier) Retourner Entier /* Objet : Operation H. */ /****************************************************************/ Debut Retourner X|((~Y)^Z); Fin Fonction /****************************************************************/ Fonction H(X:Entier, Y:Entier, Z:Entier) Retourner Entier /* Objet : Operation H. */ /****************************************************************/ Debut Retourner (X&Z)|(Y&(~Z)); Fin Fonction /****************************************************************/ Procedure FF(A:Entier Entier Sortie, B:Entier, C:Entier, D:Entier, X:Entier, S:Entier) Retourner Entier /* Objet : Operation FF. */ /****************************************************************/ Debut A+=F(B,C,D)+X; A=RotationGauche(A,S); Fin Procedure /****************************************************************/ Procedure GG(A:Entier Entier Sortie, B:Entier, C:Entier, D:Entier, X:Entier, S:Entier) Retourner Entier /* Objet : Operation GG. */ /****************************************************************/ Debut A+=G(B,C,D)+X+0X5A827999; A=RotationGauche(A,S); Fin Procedure /****************************************************************/ Procedure HH(A:Entier Entier Sortie, B:Entier, C:Entier, D:Entier, X:Entier, S:Entier) Retourner Entier /* Objet : Operation HH. */ /****************************************************************/ Debut A+=H(B,C,D)+X+0X6ED9EBA1; A=RotationGauche(A,S); Fin Procedure /****************************************************************/ Procedure II(A:Entier Entier Sortie, B:Entier, C:Entier, D:Entier, X:Entier, S:Entier) Retourner Entier /* Objet : Operation II. */ /****************************************************************/ Debut A+=I(B,C,D)+X+0X8F1BBCDC; A=RotationGauche(A,S); Fin Procedure /****************************************************************/ Procedure FFF(A:Entier Entier Sortie, B:Entier, C:Entier, D:Entier, X:Entier, S:Entier) Retourner Entier /* Objet : Operation FFF. */ /****************************************************************/ Debut A+=F(B,C,D)+X; A=RotationGauche(A,S); Fin Procedure /****************************************************************/ Procedure GGG(A:Entier Entier Sortie, B:Entier, C:Entier, D:Entier, X:Entier, S:Entier) Retourner Entier /* Objet : Operation GGG. */ /****************************************************************/ Debut A+=G(B,C,D)+X+0X6D703EF3; A=RotationGauche(A,S); Fin Procedure /****************************************************************/ Procedure HHH(A:Entier Entier Sortie, B:Entier, C:Entier, D:Entier, X:Entier, S:Entier) Retourner Entier /* Objet : Operation HHH. */ /****************************************************************/ Debut A+=H(B,C,D)+X+0X5C4DD124; A=RotationGauche(A,S); Fin Procedure /****************************************************************/ Procedure III(A:Entier Entier Sortie, B:Entier, C:Entier, D:Entier, X:Entier, S:Entier) Retourner Entier /* Objet : Operation III. */ /****************************************************************/ Debut A+=I(B,C,D)+X+0X50A28BE6; A=RotationGauche(A,S); Fin Procedure