N-hash

Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt hozzászólók, és jelentősen eltérhet a 2015. január 14-én felülvizsgált verziótól ; az ellenőrzéshez 21 szerkesztés szükséges .

N-hash
Létrehozva	1990
közzétett	1990
Hash méret	128 bites
A körök száma	12 vagy 15
Típusú	hash függvény

Az N-Hash egy kriptográfiai hash függvény , amely a FEAL ciklikus függvényen alapul . Jelenleg nem tekinthető biztonságosnak [1] .

1990 -ben fejlesztette ki a Nippon Telegraph and Telephone (a FEAL-t is).

Kezdetben az N-Hash funkciót a két telefonhasználó (Nippon Telegraph and Telephone – távközlési vállalat) közötti úton történő információcsere problémájának megoldására és az adatok visszakeresésének felgyorsítására szánták. Például, ha egy személy SMS -t küld, akkor a kézbesítés előtt egy hash funkció segítségével ellenőrzik annak hitelességét. Ha pedig a Nippon Telegraph és Telephone termékek felhasználójának gyorsan meg kell találnia valakinek a kapcsolattartóját a telefonon, akkor az N-Hash használatával leegyszerűsítheti a név megtalálásának folyamatát a listában. Ez annak a ténynek köszönhető, hogy a kapcsolat első betűje a név hash kódjaként (a kapcsolat egy kis meghatározó része) van deklarálva.

Eredet

Az N-Hash algoritmus a FEAL blokktitkosítási algoritmuson alapul. A legnagyobb távközlési vállalat, a Nippon Telegraph and Telephone megalkotta a FEAL-t a DES alapján . De bár ez az algoritmus gyorsabban teljesít a DES-nél, nagyon megbízhatatlan és könnyen sebezhető: egy kriptoanalitikusnak nagyon kevés információra volt szüksége ahhoz, hogy megtörje az algoritmust. A FEAL algoritmus feltörése vezetett az N-Hash hash függvény megjelenéséhez 1990-ben. Az N-Hash a DES-nél is gyorsabb: a DES 9 Kb/s sebességéhez képest az N-Hash 24 Kb/s sebességgel fut 15 körös sémában, és 29 Kbps sebességgel 12 körös sémában. Ugyanakkor a Nippon Telegraph and Telephone megbízhatóságának növekedését érte el a FEAL -hez képest [1] .

Egy ideig az N-Hash algoritmust használta a Nippon Telegraph and Telephone ennek a függvénynek a céljainak megfelelően, de egy idő után kifejlesztették a születésnapi módszert , amely könnyen feltörte ezt az algoritmust. A feltörés kapcsán nemcsak az N-Hash-t hagyták el, hanem szinte minden blokk titkosításra épülő funkciót, hiszen mindegyiknél ugyanaz a probléma: könnyen kiszolgáltatottak a születésnapi metódusnak. Ehelyett mostantól megbízhatóbb, MD-technológiákon alapuló funkciókat használnak: MD5 , SHA-1 és a jelenleg megbízhatónak minősülő funkciók listájában felsorolt funkciókat (az ISO / IEC 10118 szabvány szerint).

Használat

Az N-Hash függvényt rövid ideig használták az 1990-es évek elején, mígnem a születésnapi módszerrel feltörték.

Az N-Hash célja az volt, hogy megoldja az adathamisítás problémáját:
- Egy modern ember számára ez a probléma könnyen leírható egy személy és egy online áruház közötti interakció példáján . Amikor a felhasználó megrendel egy terméket egy online áruházban, az üzlet elküldi neki a rendelés számát, a fizetési összeget stb. Továbbá, amikor a felhasználó például a Webmoney segítségével próbál fizetni a rendelésért, a Webmoney kiszámítja a kapott csomag hash kódját. üzenetet, és összehasonlítja az online áruházból kapott hash kóddal. Ha ezek a hash kódok egyeznek, akkor a felhasználó által küldött információ igaz. Ha nem egyeznek, akkor az információ hamisnak minősül, és a fizetés nem megy át.
Egy másik felhasználási eset egyszerű: ábécé sorrendbe rendezze mobiltelefonján névjegyeit, és keressen rá az első betűre. Ennek a névnek az első betűje van kiválasztva a név hash kódjaként, ezért ha valaki megnyom egy bizonyos betűt a telefonjában, akkor a rendszer megkeresi a megfelelő hash kódot, és az ezzel kezdődő kapcsolatok megjelennek a képernyőn.

Az N-Hash jellemzői

Egyirányú

Definíció: Legyen egy bizonyos hosszúságú üzenet. $M$

Egy függvényt egyirányúnak nevezünk , ha egyenlőségből $H$ $h=H(M)$

könnyen:

találja meg a hash kódot az üzenet ismeretében $h$ $M$

nagyon munkaigényes:

üzenetet találni egy ismert hash kóddal (azaz ha a jelszó hash kódja a hacker tudomására jutott, akkor nem fogja megtalálni a jelszót használva); $M$ $h$
olyan üzenetet találni, amely eltér a -tól , így a hash-kódjai megegyeznek. $M$ $M'$ $H(M')=H(M)$

Egy egyszerűbb definíciót így írhatunk:

Az egyirányúság az " ujjlenyomat ":

Ha egy adott személyt megadnak, akkor leveheti az ujjlenyomatát;
Lehetetlen megtalálni az embert az ujjlenyomata alapján (ha nincs adatbázis minden ember ujjlenyomatával, de nincs);
Lehetetlen találni egy második embert, akinek ugyanaz az ujjlenyomata, mint a másiknak.

Az egyirányúság egy nagyon fontos problémát old meg. Nézzük meg egy példával.

Alice és Bob hagyományosan az információátadás tárgyait jelölik ki. Példák

Tegyük fel, hogy Alice szerződést írt alá egy Alice és Bob által ismert hash kóddal . Ha nem egyirányú lenne, akkor Bob találhatna egy ettől eltérő szerződést , amely így azt állíthatja, hogy Alice aláírta . $M$ $h=H(M)$ $H$ $M'$ $H(M')=H(M)$ $M'$
Tegyük fel, hogy Alice-nek ugyanaz az ujjlenyomata h valami bűnözővel, akkor Bob azt állíthatja, hogy ez a bűnöző Alice.

Ütközésállóság

Annak elkerülése érdekében, hogy Alice a "születésnapi" módszert alkalmazza Bob megtévesztésére, nagyon kényelmes egy még erősebb feltételt bevezetni, mint az egyirányú feltétel. H olyan, hogy nehéz megtalálni az üzeneteket , és olyan, hogy a hash kódjuk megegyezik. Vagyis lehetetlen találni két azonos ujjlenyomatú embert. $M$ $M'$ $H(M)=H(M')$

Ezt a feltételt ütközésállóságnak nevezik , és nem érvényes az N-Hash hash függvényre.

Az ütközési instabilitás miatt Alice így csaphatja be Bobot (a "születésnapi" módszer):

Alice két változatot ír a szerződésről: az egyik előnyös Bob számára, a másik pedig nem;
Azzal, hogy minden egyes szerződésen apró változtatásokat hajt végre (például egy szóközt két szóközzel helyettesít), biztosítja, hogy elegendő számú szerződés-verzió legyen kiválasztható , és amelyekhez a hash kódok egyeznek (a verzió előnyös Bob számára, de nem) (ha a szerződés 34 sorból áll, akkor az egyes sorok módosításával vagy mellőzésével könnyen beszerezhető a szerződések verziója); $M$ $M'$ $M$ $M'$ $2^{{34}}$
Most Alice bebizonyíthatja, hogy Bob aláírta . $M'$

Az ilyen problémák elkerülése érdekében elegendő az aláírt szerződés kozmetikai módosítása. És bár ez a művelet semmilyen módon nem változtatja meg a H hash függvényt, és ezért semmilyen módon nem befolyásolja annak ütközésállóságát, de ezzel a művelettel a személy megkapja a szerződés új verzióját, amelynek hash kódja nem egyezik a támadó szerződéses verziójának hash kódjával. Vagyis ha Bob az 5. sorban vesszőt tesz valahova, vagy két pontot tesz egy helyett, akkor Alice nem fogja tudni bizonyítani, hogy újabb szerződést írt alá (mivel a hash kódja már nem egyezik Alice szerződésének hash kódjával).

Vegyünk egy valós példát: amikor a közjegyző lebélyegzi az aláírt szerződést, ott kozmetikai változtatásokat hajt végre.

Az N-Hash céljai

Az N-Hash függvény működésének megértéséhez tudományosabb beszédre kell váltania. Az alábbiakban ennek a funkciónak a céljait mutatjuk be, nem példákon keresztül, hanem a megvalósítás módja szerint és a megfelelő terminológiával .

Az információ integritásának biztosítása [1] :

Erre a tulajdonságra azért van szükség, hogy kizárja annak lehetőségét, hogy egy támadó hamis információt illesszen be az eredeti üzenetbe. A sértetlenség érdekében az üzenet szövegében bekövetkező változásokat (csere, beillesztés, törlés) észlelni kell. Az integritást redundáns információk beillesztése biztosítja az eredeti üzenetbe, ami egy tesztkombináció lesz. Ezt a kombinációt ellenőrző összegnek nevezik , és egy speciális algoritmussal számítható ki. Mivel ez az algoritmus a titkos kulcstól függ , nem valószínű , hogy hamis információ kerülne az üzenetbe .

$M_{új}=M+''só''$ , ahol a só redundáns információ, M egy üzenet - ellenőrző összeg; $H(salt)=S$

A képletből az következik, hogy ha a só megváltozik, akkor S (ellenőrző összeg) is változik, ami azt jelenti, hogy mindkettő és megváltozott . $M_{új}$ $M$

Vagyis arra a következtetésre juthatunk, hogy hamis információkat adtak hozzá.

Dokumentumtömörítés : _

Az N-Hash függvény M tetszőleges hosszúságú üzenettel működik. Ebben az esetben a kimenet egy 128 bites rögzített hosszúságú hash kód. Ez annak köszönhető, hogy az üzenet 128 bites méretű blokkra van felosztva , és az algoritmus szekvenciálisan működik az egyes blokkokkal. $M_{i}$

Az elektronikus adatok megbízhatóságának biztosítása [1] :

Ez a tulajdonság egyirányú függvényekre vonatkozik, ami az N-Hash. Az M üzenet megbízhatóságát a végső hash kód (üzenetkivonat) kétszeri megkeresésével ellenőrizzük (küldő és fogadó fél). Az eredményeket összehasonlítják, és ha megegyeznek, akkor az információ megbízható. Az integritás nem garantálja az érvényességet .

A magánélet biztosítása :

azokon a webhelyeken, ahol meg kell adnia a bejelentkezési nevet és a jelszót , a beírás utáni jelszót hash kódra fordítják. Ez azt jelenti, hogy a felhasználó először beírja az M jelszavát, de egy hash kóddal lép be a védett területre . Az ismert h hash kód és a H függvény segítségével nagyon nehéz kiszámítani az M-et, ami biztosítja a jelszó titkosságát. $h=H(M)$

Felhasználó hitelesítés :

A hitelesítés a felhasználó vagy az adatok bizonyos kritériumok alapján történő hitelesítésére szolgáló eljárás.

Felmerül a kérdés, hogy a hash függvény hogyan biztosítja a hitelesítés hitelességét. Ezt könnyű példával bemutatni.

Amikor a felhasználó beír egy felhasználónevet és jelszót bármely webhelyen , a jelszavát a rendszer hash kóddá alakítja, és hitelesítés céljából továbbítja a hálózaton. Nyilván ahhoz, hogy valaki más fiókja alatt tudjunk bejelentkezni, elég kideríteni a jelszó hash kódját, majd a képlet (h-hash kód, M - jelszó) segítségével megtalálni a jelszót. De az N-Hash, amely egyirányú funkció, biztosítja a jelszó biztonságát, mivel az egyirányú függvények egyenletének megoldása nagyon munkaigényes (nem személyi számítógép használata). $h=H(M)$

Algoritmus

Az N-Hash algoritmus a műveletek ciklikus ismétlődésén (12 vagy 15-ször - a körök száma) alapul. A bemeneten van egy hash kód és ez tetszőleges lehet, a kimenet az M üzenet h hash kódja , amit ki kell hasítani. A kimenő hash kód mérete rögzített és egyenlő 128 bittel, míg az M mérete tetszőleges [2] . ${\displaystyle h_{0))$

Alapmegnevezések

$M$ — a kivonatolni kívánt üzenet;
$M_{i}$ — 128 bites üzenetblokk. Egy üzenet kivonatolásához blokkokra kell osztani ; $M$ $M_{i}$
$Szia}}$ — az i-edik lépés hash kódja;
$\nu=1010...1010$ — állandó, 128 bit hosszú;
$||$ - összefűzés ;
${\displaystyle V_{j}=\delta ||A_{j1}||\delta ||A_{j2}||\delta ||A_{j3}||\delta ||A_{j4))$ , ahol , ahol k=1, 2, 3, 4; , 24 bit hosszú; $A_{jk}=4*(j-1)+k$ $\delta =00..00$
EXG - egy funkció, amely felcseréli a magas és alacsony biteket (64 alacsony és 64 magas);
PS - transzformáló függvény;

Az algoritmus leírása

A jobb oldali diagram a következő ábrákon szereplő műveletek vázlatos megjelöléseit mutatja.

A koordináta (páronkénti) összegzés modulo 2 összeadást jelent ;
Ha x egy f függvény bemenete , akkor a kimenete f(x) .

Egy N-hash ciklus

Az alábbiakban az N-Hash algoritmus egy ciklusa látható.

A g függvény bemenete az (i-1)-edik lépés és az i-edik üzenetblokk hash kódja . Ebben az esetben tetszőlegesen van kiválasztva: például lehet nulla. És a modulo 2 összeadási művelet kimenetére is be van táplálva, vagyis az eredmény (a következő lépés hash kódja) így fog kinézni: ( valami még ismeretlen ). $h_{{i-1}}$ $M_{i}$ ${\displaystyle h_{0))$ $h_{{i-1}}$ $h_{i-1}\oplus$
A diagramból látható, hogy nem csak az XOR -ra van betáplálva , hanem a modulo 2 összeadás műveletének kimenetére is. Vagyis most az első bekezdéssel összhangban az eredmény így néz ki: ( valami, ami egyelőre ismeretlen ). $M_{i}$ ${\displaystyle h_{i-1}\oplus M_{i))$

A maradék ismeretlen valami nyolc transzformációs függvényből álló kaszkádon való áthaladás után található meg. A megszerzését így lehet leírni:

Az EXG funkció felcseréli a magas és alacsony számjegyeket , és hozzáadja az eredményt , majd az eredményt modulo 2 s- mal egészíti ki . $h_{{i-1}}$ $\nu$ $M_{i}$
A diagramból látható, hogy az eredményt szekvenciálisan j transzformáló függvény bemenetére tápláljuk, melynek második argumentuma az összeg , ahol j=1, ... , 8. ${\displaystyle h_{i-1}\oplus V_{j))$
Az eredmény az i-edik lépés hash kódja : $Szia}}$

${\displaystyle h_{i}=M_{i}\oplus g(M_{i},h_{i-1})\oplus h_{i-1))$ .

Transzformációs függvény

Felmerül a kérdés, hogyan működik a transzformációs függvény . $PS(X,P)$

Tekintsük az áramkör felső részét a szálkereszthez.

Az eredeti üzenet bitblokkokra van osztva . $x$ $128/4=32$

A közbenső kimeneteket az áramkör alsó részének bemeneteinek tekintjük. és a közbenső kimenetekre , míg a műveletek és a másik két kimenetre kerülnek . Mostantól lehetőség van a közbenső kimeneteken lévő eredmények újrajelölésére, és rajtuk keresztül – hasonlóan a felső részhez – az alsó rész kimenetén, vagyis a teljes áramkör egészében megtalálni az eredményeket. $X_{1}$ $X_{2}$ ${\displaystyle f(X_{1},P_{1})\oplus X_{2}\oplus X_{4))$ ${\displaystyle f[f(X_{1},P_{1})\oplus X_{2},P_{2}]\oplus X_{1}\oplus X_{3))$

Az összes szükséges számítás elvégzése után azt kapjuk, hogy a bemenetre alkalmazva a kimeneti üzenet üzenetek összefűzéseként ábrázolható ${X=X_{1}\parallel X_{2}\parallel X_{3}\parallel X_{4))$ ${Y=Y_{1}\parallel Y_{2}\parallel Y_{3}\parallel Y_{4}}$

${\displaystyle {Y_{4}=X_{2}\oplus X_{4}\oplus f(X_{1},P_{1)))))$ ;
${Y_{3}=f[f(X_{1},P_{1})\oplus X_{2},P_{2}]\oplus X_{1}\oplus X_{3))$ ;
${\displaystyle {Y_{2}=X_{2}\oplus Y_{4}\oplus f(Y_{3},P_{3)))))$ ;
${Y_{1}=f[f(Y_{3},P_{3})\oplus Y_{4},P_{4}]\oplus X_{1}\oplus Y_{3))$ .

Az f(x, P) függvény keresése

Mivel az f függvény argumentumokkal dolgozik, amelyek hossza 32 bit, így az f(x, P) függvény keresési sémájából a következőt kapjuk:

Az érték 8 bites részekre van felosztva. $x\oplus P$
Írjuk fel ezeket a részeket , i=1,…,4 alakban, és vezessünk be új jelölést: $x_{i}\oplus P_{i}$
- ${Z_{1}=x_{1}\oplus P_{1))$ ;
- ${Z_{2}=x_{2}\oplus P_{2))$ ;
- ${Z_{3}=x_{3}\oplus P_{3))$ ;
- ${Z_{4}=x_{4}\oplus P_{4))$ ;

A függvény argumentumai (az első nyíl balról) a és . ${S_{0))$ $Z_{1}$ ${S_{1}[Z_{1}\oplus Z_{2},Z_{3}\oplus Z_{4}]}$

A függvény argumentumai (a második nyíl balról) a és . ${S_{1))$ ${Z_{1}\oplus Z_{2}}$ ${Z_{3}\oplus Z_{4}}$

Vagyis a kimeneti üzenet két összetevője már ismert és egyenlő

- ${A_{1}=S_{0}(Z_{1},S_{1}[Z_{1}\oplus Z_{2},Z_{3}\oplus Z_{4}])}$ ;
- ${A_{2}=S_{1}[Z_{1}\oplus Z_{2},Z_{3}\oplus Z_{4}]}$ ;

Továbbá az üzenet már beérkezett elhagyó részeit használjuk a kimeneten a jelölés megkönnyítése érdekében:

- ${A_{3}=S_{0}[Z_{3}\oplus Z_{4},A_{2}]}$ ;
- ${~A_{4}=S_{1}[Z_{4},A_{3}]}$ ;

Ekkor a kimeneti üzenet a következővel ábrázolható . ${A=A_{1}||A_{2}||A_{3}||A_{4))$

És ez köztudott
- ${S_{0))$ =( balra 2 bites forgatás )(a+b) mod 256
- ${S_{1))$ =( 2 bites balra forgatás )(a+b+1) mod 256

A hash függvények biztonsága

A hash-függvény akkor biztonságos , ha a kriptaelemzőnek sok információra van szüksége a hash feltöréséhez (ezáltal nem valószínű, hogy feltörik), és ha a hash-t még nem sikerült feltörni [3] .

Ahhoz, hogy a hash funkció biztonságos legyen, a következő feltételeknek kell teljesülniük:

Az üzenet szövegének változásaival (beszúrások, permutációk stb.) az üzenet hash kódjának is meg kell változnia; $M$

Ellenkező esetben az a személy, aki beírja felhasználónevét és jelszavát a Wikipédiába való belépéshez , egy másik résztvevő oldalára kerülhet.

Lehetetlen üzenetet találni egy ismert hash kóddal innen ; $M$ $h$ $h=H(M)$

Ha ez a feltétel nem teljesül, akkor ez lehetővé teszi a Wikipédia-felhasználók jelszavainak megtalálását.

Nagyon időigényesnek kell lennie annak a feladatnak, hogy olyan üzeneteket találjunk , amelyekben a hash kódok megegyeznek . $M_{{1}}$ $M_{{2}}$ ${\displaystyle h_{1}=h_{2))$

Ellenkező esetben lehetséges lenne két jelszót találni azonos hash kóddal.

Az N-Hash nem biztonságos függvény, mert az utolsó feltétel nem teljesül.

Az N-Hash kriptanalízise

Az N-Hash jelenleg nem biztonságos szolgáltatásnak számít. Ez az ábra felsorolja az összes jelenleg biztonságos egyirányú funkciót az ISO/IEC 10118 [1] szerint :

A blokk titkosításon alapuló N-Hash-hez hasonló algoritmusok közül csak az MDC-2 és az MDC-4 tekinthető biztonságosnak .

Az N-Hash-t a következő probléma jellemzi:

Mivel a hash kód hossza megegyezik a titkosítási algoritmus blokkjának hosszával, az algoritmus instabil a születésnapi támadással szemben.

A hash függvények elleni támadások

Ez az ábra az összes kivonatolási algoritmus elleni támadások osztályozását mutatja általában.

Az algoritmusfüggő támadások egy adott algoritmus tulajdonságain alapuló támadások.

Például az N-Hash-t sikeresen megtámadták differenciális módszerrel , fixpontos támadással és középen találkozóval .

Az algoritmusfüggetlen támadások bármilyen hash függvényre alkalmazhatók, de ez nem zárja ki azt a tényt, hogy egyes algoritmusok esetében nagyon időigényesek a nagy információmennyiség vagy a kód sebessége miatt.

Hatékony támadások az N-Hash ellen

Algoritmus alapú támadások Differenciál módszer

Den Boer egy eljárást javasolt ütközés felépítésére egy egyfordulós N-Hash séma számára.

Biham és Shamir sikeresen alkalmazta a differenciális kriptoanalízist a 6 körös N-Hash séma kompromittálására . Az általuk javasolt módszer az ütközés megkonstruálására bármely N értékre működik, amely három többszöröse, ugyanakkor N ≤ 12 esetén hatékonyabbnak bizonyul, mint a születésnapi paradoxonon alapuló megközelítés .

Egy 12 körből álló séma esetén az ütközések felépítésének bonyolultsága a javasolt módszerrel 256 műveletre becsülhető (a születésnapi paradoxonon alapuló módszer összetettsége 264 művelet).

Algoritmusfüggetlen támadások

A hash kód és a titkos kulcs hosszának növelése megnehezíti a kriptoanalitikus munkáját. Megpróbálhatja a számításokat túl időigényessé tenni egy személyi számítógép számára, és nagy erőforrásokat igényel. Ekkor a kriptoanalitikusnak vagy szuperszámítógépet kell keresnie, vagy egy vírust kell írnia, amely a hash-függvény feltörési folyamatának párhuzamosítása alapján több személyi számítógépet használ egyszerre a probléma megoldására [3] .

A hash függvény [4] védelmének következő módszerei is hatékonyak :

ellenőrző összegek használata a kivonatolás különböző szakaszaiban;
az információk pontosságának ellenőrzése;
só típusú információ beágyazása az üzenetbe .

Eredmények

Jelenleg az N-Hash-t nem használják széles körben, mivel nem biztonságos, és több mint 10 éve feltörték.
Mostantól van egy speciális elnevezése a hash függvényeknek, mint például az N-Hash - key , azaz egyirányú, de nem ütközésálló:
- Ha a felek megbíznak egymásban (vagyis mindkét fél biztos abban, hogy a másik nem fogja felváltani a szerződést, mint Alice és Bob esetében), akkor az N-Hash használható.

Az N-Hash összehasonlítása más hash-függvényekkel

Algoritmus	Hash érték hossza	Titkosítási sebesség (KB/s)
Davies-Meyer szimultán kör ( IDEA -val )	128	22
Davies-Meyer (DES-szel)	64	9
GOST hash függvény	256	tizenegy
HAVAL (3 készlet)	változó	168
HAVAL (4 szett)	változó	118
HAVAL (5 készlet)	változó	98
MD2	128	23
MD4	128	236
MD5	128	174
N-Hash (12 szakasz)	128	29
N-Hash (15 szakasz)	128	24
RIPE-MD	128	182
SHA-1	160	75
Snefru (4 menet)	128	48
Snefru (8 készlet)	128	23

Jegyzetek

↑ 1 2 3 4 5 Hash függvények (elérhetetlen hivatkozás - előzmények ) . Cryptomash. Letöltve: 2008. november 27. (határozatlan) (elérhetetlen link)
↑ Bruce Schneier. 18. fejezet Egyirányú hash-függvények // Alkalmazott kriptográfia . - 2. kiadás Archiválva : 2014. február 28. a Wayback Machine -nál
↑ 1 2 A kriptográfia fő kérdése // CIO: folyóirat. - 2005. május 17. - 5. sz . Az eredetiből archiválva : 2008. május 29.
↑ Hash függvények kriptoanalízise (elérhetetlen link - történelem ) . Cryptomash. Letöltve: 2008. november 27. (határozatlan) (elérhetetlen link)

Lásd még

Linkek

Irodalom

A. Scserbakov, A. Domasev. Alkalmazott kriptográfia. - M . : orosz kiadás, 2003. - 404 p. — ISBN 5-7502-0215-1 .
Bruce Schneier. Alkalmazott kriptográfia. - 2. kiadás - M . : Triumph, 2002. - 816 p.

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