Fonctions de hachage basées sur des automates cellulaires

Une fonction de hachage est une fonction qui convertit une longueur arbitraire de données d'entrée en une séquence de bits d'une longueur fixe. Les fonctions de hachage jouent un rôle important dans la cryptographie moderne. Les progrès technologiques, de nouvelles exigences en matière de sécurité et de complexité informatique émergent. La famille d'algorithmes SHA reste le leader parmi les algorithmes de hachage dans de nombreux domaines, mais il existe une autre famille d'algorithmes basés sur des automates cellulaires qui mérite l'attention de tous.





Automates cellulaires

L'automate cellulaire est une chose assez courante qui mérite un poste séparé . Cependant, en un mot, il s'agit d'un modèle discret, qui est une grille de dimensions arbitraires, dont chaque cellule à chaque instant du temps peut prendre l'un d'un ensemble fini d'états, et la règle de transition des cellules d'un état à un autre est déterminée.





Dans le cas des automates cellulaires élémentaires, les grilles de cellules sont unidimensionnelles.





Dans un automate cellulaire, pour chaque cellule, il existe un ensemble d'autres cellules, appelées voisinage, qui déterminent l'état suivant de la cellule. L'état initial est l'état dans lequel les valeurs des cellules et leurs voisinages sont déterminés au temps t. Désormais, une nouvelle génération de cellules est créée lorsque "t" est incrémenté de 1.





30, :





C ^ {t + 1} _s = C ^ t_ {s-1} \ XOR \ (C ^ t_s \ OR \ C ^ t_ {s + 1})

:





  • , .





  • ( ).





  • .





.









?

c k, : 128, 192 256 .





  1. c :





    size (c) \ text {mod} 512 = 0 \ text {et} size (c)> = 512





    .





    C.





  2. k.





    size (k) \ text {mod} 512 = 0 \ text {et} size (k)> = 512





    k





  3. C 512 .





  4. 512 , 8 64 .





  5. 512 30.





  6. 5 512 ().





  7.   XOR 5 512 .





  8.   , 1.





  9.   6, 7 8 , 512 , .





, .





, .





64 .





  1.  a = e





    , e une





  2.  b = J (g, h, K_1)  b = J (g, h, K_5)





    ,  a = J (g, h, K_1)  a = J (g, h, K_5)





     J (x, y, z) = ((\ text {ROTL} ^ {47} (x) \ text {XOR} \, Rule \, 30 (\ text {ROTL} ^ {37} (y ')) \ text {AND} ((\ text {ROTR} ^ {17} (z)))





  3.  c = G (e, f, K_2)  c = G (e, f, K_6)





      ,  c = G (e, f, K_2)  c = G (e, f, K_6)





     G (x, y, z) = (Rule134 (Rule30 (x ')) \ text {OR} y) \ text {XOR} (Rule30 (z') \ text {AND} x)





  4.  d = F (a, c)





      F (x, y) = Rule30 (x) \ text {XOR} y '





  5.  e = J (a, d, K_4)  e = J (a, d, K_8)





      ,  e = J (a, d, K_4)  e = J (a, d, K_8)





      J 1.





  6.  f = H (b, d)





     H (x, y) = \ text {ROTL} ^ {17} (x) \ text {XOR} \ text {ROTL} ^ {59} (y)





  7.  g = I (c, f)





     I (x, y) = \ text {ROTL} ^ {41} (x ') \ text {XOR} \ text {Rule134} (\ text {Rule30} (\ text {ROTL} ^ {31} (y') ))





  8.  h = H (a, K_3)  h = H (a, K_7)





      ,  h = H (a, K_3) h = H (c, K_7)





      H 4.





ROTL — , ROTR — .





. :





 tours = '1' (512 ) + '0' (512 )  mod 512 .





30 , - . . , .





:








All Articles