RIPEMD-160

RIPEMD-160
Egyfordulós hash séma
Létrehozva	1996
közzétett	1996. április 18
Hash méret	160 bites
A körök száma	80
Típusú	hash függvény

A RIPEMD-160 (a RACE Integrity Primitives Evaluation Message Digest -ből ) egy kriptográfiai hash függvény , amelyet a Louvaini Katolikus Egyetemen fejlesztettek ki Hans Dobbertin , Anton Bosselaers és Bart Prenel . Egy tetszőleges bemeneti üzenethez a függvény egy 160 bites hash értéket generál, amelyet üzenetösszegzésnek neveznek . A RIPEMD-160 a RIPEMD továbbfejlesztett változata, amely viszont az MD4 alapelveit használta, és teljesítményében összehasonlítható a gyakoribb SHA-1-gyel .

Ennek az algoritmusnak 128, 256 és 320 bites verziója is létezik, amelyek neve RIPEMD-128 , RIPEMD-256 és RIPEMD-320 . A 128 bites verzió csak az eredeti RIPEMD helyettesítője, amely szintén 128 bites volt, és amelyben sebezhetőségeket találtak [1] . A 256 bites és 320 bites verziók dupla hosszúságú összefoglalót tartalmaznak , ami csökkenti az ütközések valószínűségét , de a funkciók már nem kriptográfiailag erősek .

A RIPEMD-160-at a nyílt akadémiai közösségben fejlesztették ki, ellentétben az SHA-1-gyel és az SHA-2-vel , amelyeket az NSA hozott létre . Másrészt a RIPEMD-160-at valamivel ritkábban használják, mint az SHA-1 -et a gyakorlatban .

A RIPEMD-160 használatát semmilyen szabadalom nem korlátozza .

A RIPEMD-160 megvalósítása

1. lépés: Hiányzó bitek hozzáadása

Az üzenetet úgy bővítjük, hogy a modulo 512 bitben kifejezett hossza 448 legyen. Így a bővítés eredményeként az üzenet 64 bittel marad el az 512 bites hossz többszörösétől. A kiterjesztés mindig megtörténik, még akkor is, ha az üzenet eredetileg megfelelő hosszúságú.

A bővítés a következőképpen történik: az üzenethez egy 1-gyel egyenlő bitet adunk, majd 0-val egyenlő biteket adunk hozzá, amíg az üzenet hossza 448 modulo 512 lesz. Összesen legalább 1 bit hozzáadódik az üzenethez , és maximum 512.

2. lépés: Üzenet hosszának hozzáadása

A 64 bites reprezentáció (az üzenet hossza a kitöltési bitek hozzáadása előtt) hozzáadódik az előző lépés eredményéhez. Abban a valószínűtlen esetben, ha nagyobb, mint , csak a legkisebb jelentőségű 64 bit kerül felhasználásra. Ezeket a biteket két 32 bites szóként adják hozzá, és először a legkevésbé jelentős biteket tartalmazó szót adják hozzá. $b$ $b$ $2^{64}$

Ebben a szakaszban (a bitek és az üzenet hosszának összeadása után) egy 512 bit többszöröse hosszúságú üzenetet kapunk. Ez egyenértékű azzal, hogy ez az üzenet 16 32 bites szó többszöröse. Minden 32 bites szó négy 8 bites szót tartalmaz, de ezek nem egymás után következnek, hanem fordítva (például nyolc 8 bites szóból (abcdefgh) két 32 bites szót (dcba hgfe) kapunk).

3. lépés: A tényleges függvények és állandók meghatározása

I. Nemlineáris bitenkénti függvények:

$f(j; x; y; z) = x \otimes y \otimes z ~~~~~~~~~~~~~~ (0 \le j \le 15)$
$f(j; x; y; z) = (x \wedge y) \lor (\neg x \wedge z)~~~ (16 \le j \le 31)$
$f(j; x; y; z) = (x \vagy \neg y) \otimes z ~~~~~~~~~~ (32 \le j \le 47 )$
$f(j; x; y; z) = (x \land z) \lor (y \land \neg z)~~~~ (48 \le j \le 63)$
$f(j; x; y; z) = x \otimes (y \lor \neg z)~~~~~~~~~ (64 \le j \le 79)$

II. Hozzáadott hexadecimális állandók:

K(j) = 0x00000000 $(0\leq j\leq 15)$
K(j) = 0x5A827999 $(16\leq j\leq 31)$
K(j) = 0x6ED9EBA1 $(32\leq j\leq 47)$
K(j) = 0x8F1BBCDC $(48\leq j\leq 63)$
K(j) = 0xA953FD4E $(64\leq j\leq 79)$
K'(j) = 0x50A28BE6 $(0\leq j\leq 15)$
K'(j) = 0x5C4DD124 $(16\leq j\leq 31)$
K'(j) = 0x6D703EF3 $(32\leq j\leq 47)$
K'(j) = 0x7A6D76E9 $(48\leq j\leq 63)$
K'(j) = 0x00000000 $(64\leq j\leq 79)$

III. 32 bites szavak kiválasztása üzenetből

r(j) = j for $(0\le j\le 15)$
r(16..31) = 7; négy; 13; egy; tíz; 6; tizenöt; 3; 12; 0; 9; 5; 2; tizennégy; tizenegy; nyolc
r(32..47) = 3; tíz; tizennégy; négy; 9; tizenöt; nyolc; egy; 2; 7; 0; 6; 13; tizenegy; 5; 12
r(48..63) = 1; 9; tizenegy; tíz; 0; nyolc; 12; négy; 13; 3; 7; tizenöt; tizennégy; 5; 6; 2
r(64..79)=4; 0; 5; 9; 7; 12; 2; tíz; tizennégy; egy; 3; nyolc; tizenegy; 6; tizenöt; 13
r'(0,15) = 5; tizennégy; 7; 0; 9; 2; tizenegy; négy; 13; 6; tizenöt; nyolc; egy; tíz; 3; 12
r'(16..31) = 6; tizenegy; 3; 7; 0; 13; 5; tíz; tizennégy; tizenöt; nyolc; 12; négy; 9; egy; 2
r'(32...47) = 15; 5; egy; 3; 7; tizennégy; 6; 9; tizenegy; nyolc; 12; 2; tíz; 0; négy; 13
r'(48..63) = 8; 6; négy; egy; 3; tizenegy; tizenöt; 0; 5; 12; 2; 13; 9; 7; tíz; tizennégy
r'(64...79) = 12; tizenöt; tíz; négy; egy; 5; nyolc; 7; 6; 2; 13; tizennégy; 0; 3; 9; tizenegy

VI. Bitforgatás balra beállítása (roll működés)

s(0,15) = 11; tizennégy; tizenöt; 12; 5; nyolc; 7; 9; tizenegy; 13; tizennégy; tizenöt; 6; 7; 9; nyolc
s(16..31)=7; 6; nyolc; 13; tizenegy; 9; 7; tizenöt; 7; 12; tizenöt; 9; tizenegy; 7; 13; 12
s(32..47)=11; 13; 6; 7; tizennégy; 9; 13; tizenöt; tizennégy; nyolc; 13; 6; 5; 12; 7; 5
s(48..63)=11; 12; tizennégy; tizenöt; tizennégy; tizenöt; 9; nyolc; 9; tizennégy; 5; 6; nyolc; 6; 5; 12
s(64..79)=9; tizenöt; 5; tizenegy; 6; nyolc; 13; 12; 5; 12; 13; tizennégy; tizenegy; nyolc; 5; 6
s'(0,15) = 8; 9; 9; tizenegy; 13; tizenöt; tizenöt; 5; 7; 7; nyolc; tizenegy; tizennégy; tizennégy; 12; 6
s'(16..31) = 9; 13; tizenöt; 7; 12; nyolc; 9; tizenegy; 7; 7; 12; 7; 6; tizenöt; 13; tizenegy
s'(32..47) = 9; 7; tizenöt; tizenegy; nyolc; 6; 6; tizennégy; 12; 13; 5; tizennégy; 13; 13; 7; 5
s'(48..63) = 15; 5; nyolc; tizenegy; tizennégy; tizennégy; 6; tizennégy; 6; 9; 12; 9; 12; 5; tizenöt; nyolc
s'(64..79) = 8; 5; 12; 9; 12; 5; tizennégy; 6; nyolc; 13; 6; 5; tizenöt; 13; tizenegy; tizenegy

V. Az összefoglaló szavak kezdeti jelentései

h0 = 0x67452301;
h1 = 0xEFCDAB89;
h2 = 0x98BADCFE;
h3 = 0x10325476;
h4 = 0xC3D2E1F0;

4. lépés: Hajtsa végre a kivonatolási algoritmust

Miután beállította az összes kezdeti függvényt, állandót és a hash összegű szavak kezdeti értékét, folytathatja az algoritmus végrehajtását. Az üzenetfeldolgozás 512 bites blokkokban történik, amelyek 16, egyenként 32 bites szóból állnak (16 * 32 = 512). Minden blokk feldolgozása kétféleképpen történik, és az eredmények bizonyos módon összeadódnak.

Az alábbiakban az algoritmus pszeudokódja látható. A "+" összeadás modulo 2 32 összeadást jelent , a rol s ciklikus eltolódást jelöl balra s pozícióval. Az eredeti üzenet, amely t16 32 bites szóból álló blokkokból áll, a , , [2] tömbben tárolódik . Xi[j]0 <= i < t0 <= j < 16

for i := 0 to (t - 1) { A := h0; B:= h1; C = h2; D := h3; E := h4; A' := h0; B' := h1; C' := h2; D' := h3; E' := h4; j esetén := 0-tól 79-ig { T := rol s(j) (A + f(j; B; C; D) + Xi [ r(j)] + K(j)) + E; A := E; E := D; D: = 10. tekercs (C); C:= B; B := T; T := rol s'(j) (A' + f(79 - j; B'; C'; D') + Xi [ r'(j)] + K'(j)) + E'; A' := E'; E' := D'; D' := 10. tekercs (C'); C' := B'; B' := T; } T:= h1 + C + D'; h1 := h2 + D + E'; h2 := h3 + E + A'; h3 := h4 + A + B'; h4:= h0 + B + C'; h0 := T; }

Példák RIPEMD-160 hash-ekre

A bemeneti karakterlánc ASCII karakterekből áll . A kimeneti karakterlánc hexadecimális jelölés.

RIPEMD-160(" A gyors barna róka átugrik a lusta kutyán ") = 37f332f68db77bd9d7edd4969571ad671cf9dd3b

Még egy üzenet kis változtatása is jelentős változást okoz az összefoglalójában . Például a fenti példában a következőre dcseréljük c:

RIPEMD-160 ("A gyors barna róka átugrik a lusta fogaskeréken") = 132072df690933835eb8b6ad0b77e7b6f14acad7

Egy üres karakterlánc hash összege így néz ki:

RIPEMD-160("") = 9c1185a5c5e9fc54612808977ee8f548b2258d31

Teljesítmény

Az összehasonlító táblázat az MD4-szerű függvények végrehajtási sebességét mutatja. Feltételezzük, hogy a végrehajtási kód és az adatok a végrehajtó eszköz gyorsítótárában vannak.

Algoritmus	Ciklusok	Mbps	Relatív teljesítmény
MD4	241	191.2	1.00
MD5	337	136.7	0,72
RIPEMD	480	96,0	0,50
RIPEMD-128	592	77.8	0,41
SHA-1	837	55.1	0,29
RIPEMD-160	1013	45.5	0.24

Linkek

http://homes.esat.kuleuven.be/~bosselae/ripemd160.html Archiválva : 2005. december 14. a Wayback Machine -nél
https://web.archive.org/web/20081224172439/http://homes.esat.kuleuven.be/~cosicart/pdf/AB-9601/ (Forráskódok)

Jegyzetek

↑ Ütközések md4-szerű függvényekben http://eprint.iacr.org/2004/199.pdf Archivált : 2009. szeptember 17. a Wayback Machine -nél
↑ RMD160 archiválva : 2019. február 2. a Wayback Machine -nél

Hash függvények
Általános rendeltetésű	Adler-32 CRC Fletcher ellenőrző összeg FNV MurmurHash2 MurmurHash2A MurmurHash3 PJW-32 TTH – Hash Tree jenkins hash hash összeg
Kriptográfia	Stribog GOST R 34.11-94 Öv BLAKE BMW CubeHash VISSZHANG edonkey2k FSB Fúga Grostl HAVAL Hamsi JH Kupyna LM hash Luffa MD2 MD4 MD5 MD6 N-hash RIPEMD-128 RIPEMD-160 RIPEMD-256 RIPEMD-320 SHA-1 SHA-2 Keccak (SHA-3) SHABAL SHAvite-3 SIMD SWIFFT Bőr Snefru Tigris Örvény
Kulcsgenerálási funkciók	bcrypt PBKDF2 scrypt Argon2 Lyra2
Csekkszám ( összehasonlítás )	Ellenőrző összeg Verhouff algoritmusa Hold algoritmus Damm algoritmus Vonalkód bankszámlák bankkártyák VAN SNILS OKPO ÓN OKATO ISBN OGRN és OGRNIP VIN
Hashes	A csekkszámok összehasonlítása Hitelesítési protokollok Vonalkód összehasonlítás Kriptográfia Mágneses kapcsolat Merkle aláírása ed2k URNA