Secure Hash Standard 256

Algorithme utilisé par Up ! Security Manager

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 huit registres H0, H1, H2, H3, H4, H5, H6, H7 dont les valeurs changent par application d'opérations paramétrées par leurs valeurs précédentes et le contenu du flux.

L'algorithme nécessite en plus :

• Une mémoire de travail sous forme d'un tableau W de 64 entiers de 32 bits non signés.
• Huit sous-registres A, B, C, D, E, F, G, H de 32 bits non signés.
• 64 constantes conservées dans le tableau K.
• Des variables de travail entières sur 32 bits non signés dénommées S0, S1, Maj, T1, T2, Ch.

Voici l'algorithme Sha-256 :

• Initialisation.
  H0=0x67452301;
H1=0xefcdab89;
H2=0x98badcfe;
H3=0x10325476;
H4=0xc3d2e1f0;
H5=0xc3d2e1f0;
H6=0xc3d2e1f0;
H7=0xc3d2e1f0;
K[0]=0x428a2f98;
K[1]=0x71374491;
K[2]=0xb5c0fbcf;
K[3]=0xe9b5dba5;
K[4]=0x3956c25b;
K[5]=0x59f111f1;
K[6]=0x923f82a4;
K[7]=0xab1c5ed5;
K[8]=0xd807aa98;
K[9]=0x12835b01;
K[10]=0x243185be;
K[11]=0x550c7dc3;
K[12]=0x72be5d74;
K[13]=0x80deb1fe;
K[14]=0x9bdc06a7;
K[15]=0xc19bf174;
K[16]=0xe49b69c1;
K[17]=0xefbe4786;
K[18]=0x0fc19dc6;
K[19]=0x240ca1cc;
K[20]=0x2de92c6f;
K[21]=0x4a7484aa;
K[22]=0x5cb0a9dc;
K[23]=0x76f988da;
K[24]=0x983e5152;
K[25]=0xa831c66d;
K[26]=0xb00327c8;
K[27]=0xbf597fc7;
K[28]=0xc6e00bf3;
K[29]=0xd5a79147;
K[30]=0x06ca6351;
K[31]=0x14292967;
K[32]=0x27b70a85;
K[33]=0x2e1b2138;
K[34]=0x4d2c6dfc;
K[35]=0x53380d13;
K[36]=0x650a7354;
K[37]=0x766a0abb;
K[38]=0x81c2c92e;
K[39]=0x92722c85;
K[40]=0xa2bfe8a1;
K[41]=0xa81a664b;
K[42]=0xc24b8b70;
K[43]=0xc76c51a3;
K[44]=0xd192e819;
K[45]=0xd6990624;
K[46]=0xf40e3585;
K[47]=0x106aa070;
K[48]=0x19a4c116;
K[49]=0x1e376c08;
K[50]=0x2748774c;
K[51]=0x34b0bcb5;
K[52]=0x391c0cb3;
K[53]=0x4ed8aa4a;
K[54]=0x5b9cca4f;
K[55]=0x682e6ff3;
K[56]=0x748f82ee;
K[57]=0x78a5636f;
K[58]=0x84c87814;
K[59]=0x8cc70208;
K[60]=0x90befffa;
K[61]=0xa4506ceb;
K[62]=0xbef9a3f7;
K[63]=0xc67178f2;

• Pour chaque tranche de 64 octets du flux à signer :
  La variable Buffer contient la tranche des 64 octets du contenu à signer.
  • Initialisation des registres.
    A=H0;
B=H1;
C=H2;
D=H3;
E=H4;
F=H5;
G=H6;
H=H7;

  • Initialisation de la mémoire de travail.
    Variable
    /******/
    
    I : Entier;
    
    Pour I=0 JusquA 15 Faire
    
    W[I]=Buffer[I];
    
    Fin Pour
    
  • Extension de la mémoire de travail.
    Variable
    /******/
    
    I : Entier;
    
    Pour I=16 JusquA 63 Faire
    
    S0=(W[i-15]>>7)^(W[i-15]>>18)^Rotation(W[i-15],3));
    S1=(W[i-2]>>17)^(W[i-2]>>19)^Rotation(W[i-2],10));
    W[i]=W[i-16]+S0+W[i-7]+S1);
    
    Fin Pour
    
  • Signature.
    Variable
    /******/
    
    I : Entier;
    
    Pour I=0 JusquA 19 Faire
    
    S0=Rotation(A,2)^Rotation(A,13)^Rotation(A,22);
    Maj=(A&B)^(A&C)^(B&C);
    T2=S0+Maj;
    S1=Rotation(E,6)^Rotation(E,11)^Rotation(E,25);
    Ch=(E&F)^((~E)&G);
    T1=H+S1+Ch+K[i]+W[i];
    H=G;
    G=F;
    F=E;
    E=D+T1;
    D=C;
    C=B;
    B=A;
    A=T1+T2;
    
    Fin Pour
    
  • Incrémentation des registres.
    H0+=A;
H1+=B;
H2+=C;
H3+=D;
H4+=E;
H5+=F;
H6+=G;
H7+=H;

• Terminaison.
  La signature est composée des octets de H0, H1, H2, H3, H4, H5, H6, H7.

Le flux est toujours prolongé de la sorte que sa taille soit toujours un multiple de 64 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 H0, H1, H2, H3, H4, A, B, C, D, E sont encodés obligatoirement dans l'ordre poids faible puis poids fort.

Opérations