MD6

MD6
Létrehozva 2008
közzétett 2008
Hash méret változó, 0<d≤512
A körök száma változó. Alapértelmezett, Kulcs nélkül=40+[d/4], kulcs=max(80,40+(d/4))
Típusú hash függvény

Az MD6 ( Message Digest 6 ) egy  változó hosszúságú kivonatoló algoritmus , amelyet Ronald Rivest professzor , a Massachusetts Institute of Technology munkatársa fejlesztett ki 2008 -ban [1] . Tetszőleges hosszúságú "ujjlenyomatok" vagy üzenetkivonatok létrehozására tervezték . A kevésbé fejlett MD5 helyettesítésére javasolták . A szerzők szerint az algoritmus ellenáll a differenciális kriptoanalízisnek. A közzétett üzenetek sértetlenségének és bizonyos értelemben hitelességének ellenőrzésére szolgál az üzenetkivonat és a közzétett üzenet összehasonlítása révén. Ezt a műveletet hash ellenőrzésnek nevezik. A hash függvényeket széles körben használják fix hosszúságú kulcsok generálására is titkosítási algoritmusokhoz egy adott kulcskarakterlánc alapján.

Történelem

Az MD6 egyike azoknak az üzenetösszesítő algoritmusoknak, amelyeket Ronald L. Rivest professzor , a Massachusetts Institute of Technology munkatársa fejlesztett ki. Az MD6-ot először a Crypto 2008 konferencián mutatták be, mint az SHA-3 szabvány jelöltjét . Később azonban, 2009-ben, ugyanazon a konferencián a Rivest kijelentette, hogy az MD6 még nem áll készen arra, hogy szabvánnyá váljon. Az MD6 hivatalos honlapján azt nyilatkozta, hogy bár a kérelmet formálisan nem vonják vissza, az algoritmusnak még mindig vannak problémái a sebességgel, és nem tud biztonságot nyújtani a csökkentett körszámú verzióban [2] . Ennek eredményeként az MD6 nem jutott be a verseny második fordulójába. Korábban, 2008 decemberében a Fortify Software egyik kutatója puffertúlcsordulási hibát fedezett fel az eredeti MD6 implementációban. 2009. február 19-én Rivest professzor közzétette ennek a hibának a részleteit, és egy implementációs javítást is készített [3] .

Algoritmus

A hash függvény algoritmusa nagyon eredeti ötleteket használ. Egy menetben 512 bájt kerül feldolgozásra, ami megnehezíti számos támadás végrehajtását, és megkönnyíti a párhuzamosítást, amelyet a fastruktúrákhoz is használnak.

Bemeneti adatok és eljárások

M eredeti üzenet hossza m , 1 ≤ m ≤ (2 64 - 1) bit
d az eredményül kapott hash hossza bitben, 1 ≤ d ≤ 512
K tetszőleges kulcsérték a keylen bájtok hosszúságában (0 ≤ keylen ≤ 64), jobb oldalon nullákkal kitömve 64-es számmal - keylen
L nem negatív 1 bájtos paraméter, 0 ≤ L ≤ 64 (alapértelmezett L = 64), jelzi a párhuzamos számítások számát és a fa mélységét
r 12 bites, nem negatív paraméter: körök száma (alapértelmezett r = 40 + [ d /4])
K egy 15 elemből álló 8 bájtos tömb, értéke alább látható
ƒ MD6 tömörítési funkció, amely 712 bájt bemeneti adatot (beleértve az 512 bájtos B blokkot is) 128 bájtos C eredményre konvertál r kiértékelési kör használatával
PAR párhuzamos zsugorítási művelet minden faszinthez, soha nem hívják meg, ha L = 0
SEQ soros tömörítési művelet, soha nem hívják meg, ha L = 64
Q = {0x7311c2812425cfa0, 0x6432286434aac8e7, 0xb60450e9ef68b7c1, 0xe8fb23908d9f06f1, 0xdd2e76cba691e5bf, 0x0cd0d63b2c30bc41, 0x1f8ccf6823058f8a, 0x54e5ed5b88e3775d, 0x4ad12aae0a6d6031, 0x3e7f16bb88222e0d, 0x8af8671d3fb50c2c, 0x995ad1178bd25c31, 0xc878c1dd04c4b633, 0x3b72066c7a1552ac, 0x0d6f3522631effcb}

Q tömb

Alapeljárás

Inicializálás

Jelölje l = 0, M 0 = M , m 0 = m .

Főhurok
  • l = l + 1.
  • Ha l = L + 1, akkor a SEQ( M l-1 , d , K , L , r ) értéket adja vissza eredményként.
  • Ml = PAR(Ml - 1 , d , K , L , r , l ) . Jelölje m l M l hosszát bitben.
  • Ha m l = 8 * c (azaz M l 8 * c bájt hosszú), adja vissza M l utolsó d bitjét . Ellenkező esetben visszatérünk a ciklus elejére.

PAR művelet

A PAR egy m l = 1024 * max(1, [ m l-1 / 4096]) hosszúságú üzenetet ad vissza .

Eljárás törzse
  • Ha szükséges, bontsa ki az M l-1 -et, nulla bitet adva jobbra, amíg a hossza 512 bájt többszöröse lesz. Most osszuk fel M l-1- et B 0 , B 1 , …, B j-1 blokkra , ahol j = max(1, [ m l-1 / 512]);
  • Minden B i , i = 0, 1, …, j - 1 blokkhoz párhuzamosan számítjuk ki C i - t a következő algoritmus szerint:
  • Jelölje p a kitöltött bitek számát B i , 0 ≤ p ≤ 4096. ( p mindig nagyobb nullánál, ha i = j - 1.);
  • Jelölje z = 1, ha j = 1, ellenkező esetben z = 0;
  • Jelölje V -t 8 bájtos r ǁ L ǁ z ǁ p ǁ keylen ǁ d értékként így:
  • 4 bit nulla;
  • 12 bit r ;
  • 8 bites L ;
  • 4 bites z ;
  • 16 bites p ;
  • 8 bites keylen .
  • 12 bites d .
  • Jelöljük U = l * 2 56 + i – az aktuális blokk egyedi 8 bájtos azonosítója;
  • C i = ƒ( Q ǁ K ǁ U ǁ V ǁ B i ).
  • Visszaadjuk M l = C 0 ǁ C 1 ǁ … ǁ C j-1 .

Művelet SEQ

A SEQ d bit hosszúságú hash-t ad vissza . Ezt a műveletet soha nem hívják meg, ha L = 64.

Eljárás törzse
  • Legyen C -1 egy 128 bájt hosszúságú nullvektor.
  • Ha szükséges, akkor az M L -t kibővítjük , nulla bitet adva jobbra, amíg hossza 384 bájt többszöröse lesz. Most osszuk fel M L -t B 0 , B 1 , …, B j-1 blokkra , ahol j = max(1, [ m L / 384]).
  • Minden B i , i = 0, 1, …, j - 1 blokkhoz párhuzamosan számítjuk ki C i - t a következő algoritmus szerint:
  • Jelölje p a kitöltött bitek számát B i , 0 ≤ p ≤ 3072. ( p mindig nagyobb nullánál, ha i = j - 1.);
  • Jelölje z = 1, ha i = j - 1, ellenkező esetben z = 0;
  • Jelölje V -t 8 bájtos r ǁ L ǁ z ǁ p ǁ keylen ǁ d értékként , ugyanúgy, mint az előző műveletben;
  • Jelölje U = ( L + 1) * 2 56 + i – az aktuális blokk egyedi 8 bájtos azonosítója;
  • C i = ƒ( Q ǁ K ǁ U ǁ V ǁ C i-1 ǁ B i ).
  • A C j-1 érték utolsó d bitjét adjuk vissza végső hash-ként.

MD6 tömörítési funkció

Bemeneti és kimeneti adatok

A függvény bemenetként egy N tömböt vesz fel , amely n = 89 8 bájtos szóból (712 bájt) és az r körök számából áll .
A függvény egy 16 elemből álló, 8 bájtos C tömböt ad vissza.

Konstansok
t0 _ t1_ _ t2_ _ t3_ _ t4_ _
17 tizennyolc 21 31 67
( i - n ) mód 16 0 egy 2 3 négy 5 6 7 nyolc 9 tíz tizenegy 12 13 tizennégy tizenöt
r i-n tíz 5 13 tíz tizenegy 12 2 7 tizennégy tizenöt 7 13 tizenegy 7 6 12
l i-n tizenegy 24 9 16 tizenöt 9 27 tizenöt 6 2 29 nyolc tizenöt 5 31 9

S i-n = S | (in)/
16S | 0 = 0x0123456789abcde
S* = 0x7311c2812425cfa0
S | j+1 = ( S | j <<< 1) ⊕ ( S | j ^ S*)

Funkció törzse

Jelölje t = 16 r . (16 lépés lesz minden körben)
Legyen A [0.. t + n - 1] t + n 8 bájtos elemekből álló tömb . Az első n elemet ki kell másolni az N bemeneti tömbből .

A fő függvényhurok így néz ki:
i = n - t + n - 1 esetén: /* t lépések */

x = S i-n ⊕ A i-n ⊕ A i-t 0 x = x ⊕ (A i-t 1 ^ A i-t 2 ) ⊕ (A i-t 3 ^ A i-t 4 ) x = x ⊕ (x >> r i-n ) Ai = x ⊕ (x << l i-n )

Return A [ t + n - 16 .. t + n - 1].

Jegyzetek

  1. ↑ Ronald L. Rivest, Az MD6 hash függvény Javaslat a NIST számára az SHA-3-hoz Archiválva : 2020. november 9. a Wayback Machine -nél
  2. ↑ Schneier, Bruce MD6 kikerült az SHA-3 versenyből (a link nem érhető el) (2009. július 1.). Letöltve: 2009. július 9. Az eredetiből archiválva : 2012. március 21.. 
  3. ↑ Archivált másolat (a hivatkozás nem elérhető) . Hozzáférés dátuma: 2010. november 28. Az eredetiből archiválva : 2012. február 22. 

Linkek

 Hash függvények
Általános rendeltetésű
Kriptográfia
Kulcsgenerálási funkciók
Csekkszám ( összehasonlítás )
Hashes