GOST R 34.11-94

Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt hozzászólók, és jelentősen eltérhet a 2014. december 29-én felülvizsgált verziótól ; az ellenőrzések 55 szerkesztést igényelnek .

GOST R 34.11-94
Létrehozva	1994
közzétett	1994. május 23
Lemondás dátuma	2013. január 1. [1] [2]
Utód	GOST R 34.11-2012 "Stribog", DSTU 7564:2014 "Kupyna"
Hash méret	256 bites
A körök száma	egy
Típusú	hash függvény

GOST R 34.11-94 „ Informatika. Az információk kriptográfiai védelme. A hash függvény "egy elavult orosz kriptográfiai szabvány a hash függvény kiszámításához , a GOST R 34.10-94 alapján. A FÁK -országokban újra kiadták és a GOST 34.311-95 államközi szabványként használták .

A szabvány meghatároz egy algoritmust és eljárást egy karaktersorozat hash függvényének kiszámításához. Ez a szabvány kötelező kivonatolási algoritmusként az Orosz Föderáció állami szervezeteiben és számos kereskedelmi szervezetben.

2013-ig az Orosz Föderáció Központi Bankja megkövetelte a GOST R 34.11-94 használatát a rendelkezésére bocsátott dokumentumok elektronikus aláírásához [3] .

2013. január 1-jétől az Orosz Föderációt a GOST R 34.11-2012 "Stribog" [4] , 2019. június 1- től pedig a FÁK-országokban a GOST 34.11-2018 [5] váltotta fel .

2022. január 1- ig Ukrajnában a DSTU 4145-2002 - vel együtt használják elektronikus digitális aláírás céljából [6] .

Bevezető jelölés

A kivonatolási algoritmus leírásához a következő jelölést használjuk:

$\mathcal{f}0\mathcal{g}^j$ egy j bites blokk, amely nullákkal van kitöltve.
$\mathcal{j}M\mathcal{j}$ — M blokkhossz bitben modulo 2 256 .
$\mathcal{k}$ — két blokk egyesítése ( összefűzése ) eggyé.
$+$ - két 256 bit hosszúságú modulo 2 256 blokk hozzáadása
$\oplus$ - két azonos hosszúságú blokk bitenkénti összeadása ( XOR ).

Továbbá feltételezzük, hogy a blokk legkevésbé jelentős (nulla) bitje a jobb oldalon, a legjelentősebb - a bal oldalon található.

Leírás

A leírt hash függvény alapja a kivonatoló lépésfüggvény , ahol , , 256 bites blokkok. $H_{out}\ =\ f(H_{in}, m)$ $H_{out}$ $H_{in}$ $m$

A bemeneti üzenet 256 bites blokkokra van felosztva . Ha az utolsó blokk mérete kisebb, mint 256 bit, akkor balra nullákat adunk hozzá a megadott blokkhossz eléréséhez. $M$ $m_{n}, m_{n-1}, m_{n-2}, ... , m_{1}$ $m_{n}$

Minden üzenetblokk az elsőtől kezdve egy lépésfüggvénybe kerül a közbenső hash érték kiszámításához: Az érték tetszőlegesen választható.
$H_{i+1}=f(H_{i},m_{i})$
$H_1$

A számítás után a végső hash értéket a következőképpen kapjuk meg: $H_{n+1}$

$H_{n+2}\ =\ f(H_{n+1},\ L)$ , ahol L az M üzenet hossza modulo bitben $2^{256}$
$h\ =\ f(H_{n+2},\ K)$ , ahol K az M üzenet ellenőrző összege: $m_1 + m_2 + m_3 + ... + m_n$

h az M üzenet hash értéke

Algoritmus

Inicializálás:
1. $h\ := H_1$ — A hash függvény kezdeti értéke. Vagyis egy 256 bites IV vektor, amelyet a felhasználó határoz meg.
2. $\Sigma\ :=\ 0$ - Ellenőrző összeg
3. $L\ :=\ 0$ — Az üzenet hossza
Belső iterációs tömörítési függvény: i = 1 ... n - 1 esetén tegye a következőket (egyelőre ): $|M|>256$
1. $h\ :=\ f(h,\ m_i)$ - a szekvenciális hash módszer iterációja
2. $L\ :=\ L\ +\ 256$ - az üzenethossz-számítás iterációja
3. $\Sigma\ :=\ \Sigma\ +\ m_i$ - az ellenőrző összeg számítás iterációja
Végső iterációs tömörítési funkció:
1. $L\ :=\ L\ +\ \mathcal{j}\ m_n\ \mathcal{j}$ - az üzenet teljes hosszának kiszámítása
2. $m_{n}\ :=\ {\mathcal {f}}0{\mathcal {g}}^{256\ -\ {\mathcal {j}}m_{n}{\mathcal {j}} }{\mathcal {k}}m_{n}$ - az utolsó blokk betömése
3. $\Sigma\ :=\ \Sigma\ +\ m_n$ - az üzenet ellenőrző összegének kiszámítása
4. $h\ :=\ f(h,\ m_n)$
5. $h\ :=\ f(h,\ L)$ - MD - Nyereség
6. $h\ :=\ f(h,\ \Sigma)$
Kijárat. A hash értéke h,

Megjegyzés: mivel az üzenet hossza részt vesz a kivonatolásban, nem kell feltüntetni a blokkhoz hozzáadott nullák számát az elküldött üzenetben . $m_n$

Jellemzők GOST R 34.11-94

A blokkok feldolgozásakor a transzformációkat a GOST 28147-89 algoritmus szerint használjuk ;
Egy 256 bites blokk kerül feldolgozásra, és a kimeneti érték is 256 bit hosszú.
Meghatározza az eredeti üzenet összes blokkjára kiszámított ellenőrző összeget, amely a végső hash számítás része, ami némileg megnehezíti az ütközési támadást.
Az utolsó blokk hiányosságán alapuló ütközésgátló keresési intézkedéseket alkalmaznak.
A blokkok feldolgozása a GOST 28147-89 titkosítási algoritmus szerint történik , amely S-blokkon transzformációkat tartalmaz, ami jelentősen megnehezíti a differenciális kriptográfiai módszer alkalmazását az ütközések keresésében.

Algoritmus a kivonatolási lépésfüggvény kiszámításához

A step hash függvény két 256 bites blokkot képez le egy 256 bites blokkra , és három részből áll: $f$ $H_{out}\ =\ f(H_{in},\ m)$

Kulcsgenerálás $K_1,\ K_2,\ K_3,\ K_4$
Titkosítás átalakítása – Titkosítás kulcsok használatával $\H_{in}$ $K_1,\ K_2,\ K_3,\ K_4$
A titkosítási eredmény véletlenszerű átalakítása

Kulcsgenerálás

A kulcsgeneráló algoritmus a következőket használja:

A 256 bites blokkok két átalakítása:
- Transzformáció , ahol az Y blokk 64 bites részblokkjai vannak. $A(Y)=A(y_4\ \mathcal{k}\ y_3\ \mathcal{k}\ y_2\ \mathcal{k}\ y_1) = (y_1 \oplus y_2)\ \mathcal{k}\ y_4\ \ mathcal{k}\ y_3\ \mathcal{k}\ y_2$ $y_1,\ y_2,\ y_3,\ y_4$
- Transzformáció , ahol , és az Y blokk 8 bites részblokkjai. $P(Y) = P(y_{32} \mathcal{k} y_{31} \mathcal{k} \dots \mathcal{k} y_1) = y_{\varphi(32)} \mathcal{k} y_{ \varphi(31)} \mathcal{k} \dots \mathcal{k} y_{\varphi(1)}$ $\varphi (i + 1 + 4(k - 1))= 8i + k,\ i = 0, \pontok, 3,\ k = 1, \pontok, 8$ $y_{32},\ y_{31},\ \pontok,\ y_{1}$

Három állandó:

C2 = 0 C 3 = 0xff00ffff000000ffff0000ff00ffff0000ff00ff00ff00ffff00ff00ff00ff00 C4 = 0

Algoritmus:

$U\ :=\ H_{in},\quad V\ :=\ m,\quad W\ :=\ U\ \oplus\ V,\quad K_1\ =\ P(W)$
Ha j = 2,3,4, akkor a következőket tesszük: $U := A(U) \oplus C_j,\quad V := A(A(V)),\quad W := U \oplus V,\quad K_j = P(W)$

Titkosítási átalakítás

A kulcsok előállítása után a titkosítás a GOST 28147–89 szerint történik egyszerű kulcscsere módban (for ), a titkosítási eljárást E jelöli (Megjegyzés: a GOST 28147 szerinti E titkosítási funkció 64 bites adatokat titkosít egy 256 bites kulcs). A titkosításhoz négy, egyenként 64 bites blokkra vannak osztva: és mindegyik blokk titkosított: $H_{in}$ $K_i$ $i:= 1, 2, 3, 4$ $H_{in}$ $H_{in} = h_4 \mathcal{k} h_3 \mathcal{k} h_2 \mathcal{k} h_1$

$s_1 = E(h_1, K_1)$
$s_2 = E(h_2, K_2)$
$s_3 = E(h_3, K_3)$
$s_4 = E(h_4, K_4)$

Ezt követően a blokkokat egy 256 bites blokkba állítják össze: $S = s_4 \mathcal{k} s_3 \mathcal{k} s_2 \mathcal{k} s_1$

Véletlenszerű átalakítás

Az utolsó lépés a , S és m megkeverése egy shift regiszter segítségével, ami a következőt eredményezi: . $H_{in}$ $H_{out}$

Az átalakítási folyamat leírásához először definiálni kell egy ψ függvényt, amely egy 256 bites blokkot elemi transzformációt hajt végre azonos hosszúságú blokkká: , ahol az Y blokk 16 bites részblokkjai vannak. $\psi(Y) = \psi(y_{16} \mathcal{k} y_{15} \mathcal{k} ... \mathcal{k} y_2 \mathcal{k} y_1) = (y_1 \oplus y_2 \ oplus y_3 \oplus y_4 \oplus y_{13} \oplus y_{16}) \mathcal{k} y_{16} \mathcal{k} y_{15} \mathcal{k} ... \mathcal{k} y_3 \mathcal{k} y_2$ $y_{16}, y_{15}, ... , y_{2}, y_{1}$

A keverési transzformáció alakja , ahol az i hossz szuperpozícióját jelöli . Más szavakkal, a transzformáció egy lineáris visszacsatolású eltolási regiszter , és az i index a körök számát jelzi. $H_{out} = {\psi}^{61}(H_{in} \oplus \psi(m \oplus {\psi}^{12}(S)))$ ${\psi}^i$ $\psi\circ\psi\circ\cdots\circ\psi$ $\psi$

Csere csomópontok (S-blokkok)

A titkosítási transzformációként használt GOST 28147-89 algoritmus paramétere nyolc cserecsomópont (S-box) táblázata. A GOST R 34.11-94 nem rögzíti az S-boxok és a H 1 kezdővektor értékeit , ami a hash függvény inkompatibilis megvalósítását eredményezte. $E(h, K)$

Két széles körben használt paraméterkészlet létezik, amelyek feltételezik, hogy a kezdővektor nullával egyenlő:

H 1 =0x00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000,

de az alább megadott S-box értékekkel.

Az RFC 4357 által meghatározott cserecsomópontok

Azonosító: id-GostR3411-94-TestParamSet

OID: 1.2.643.2.2.30.0

S-blokk szám	Jelentése
S-blokk szám	0	egy	2	3	négy	5	6	7	nyolc	9	A	B	C	D	E	F
egy	négy	A	9	2	D	nyolc	0	E	6	B	egy	C	7	F	5	3
2	E	B	négy	C	6	D	F	A	2	3	nyolc	egy	0	7	5	9
3	5	nyolc	egy	D	A	3	négy	2	E	F	C	7	6	0	9	B
négy	7	D	A	egy	0	nyolc	9	F	E	négy	6	C	B	2	5	3
5	6	C	7	egy	5	F	D	nyolc	négy	A	9	E	0	3	B	2
6	négy	B	A	0	7	2	egy	D	3	6	nyolc	5	9	C	F	E
7	D	B	négy	egy	3	F	5	9	0	A	E	7	6	nyolc	2	C
nyolc	egy	F	D	0	5	7	A	négy	9	2	3	E	6	B	nyolc	C

Ezeket a cserecsomópontokat a GOST R 34.11-94 "A függeléke" határozza meg tesztelési célból [7] , azzal az ajánlással, hogy csak tesztesetekben használják őket. Ezek azonban széles körben elterjedtek. Például ezeket az RFC 5831 írja le, és az Orosz Föderáció Központi Bankja használja őket alkalmazásaikban . [nyolc]

Azonosító: id-GostR3411-94-CryptoProParamSet

OID: 1.2.643.2.2.30.1

S-blokk szám	Jelentése
S-blokk szám	0	egy	2	3	négy	5	6	7	nyolc	9	A	B	C	D	E	F
egy	A	négy	5	6	nyolc	egy	3	7	D	C	E	0	9	2	B	F
2	5	F	négy	0	2	D	B	9	egy	7	6	3	C	E	A	nyolc
3	7	F	C	E	9	négy	egy	0	3	B	5	2	6	A	nyolc	D
négy	négy	A	7	C	0	F	2	nyolc	E	egy	6	5	D	B	9	3
5	7	6	négy	B	9	C	2	A	egy	nyolc	0	E	F	D	3	5
6	7	6	2	négy	D	9	F	0	A	egy	5	B	nyolc	E	C	3
7	D	E	négy	egy	7	0	5	A	3	C	nyolc	F	6	2	9	B
nyolc	egy	3	A	9	5	B	négy	F	nyolc	6	7	E	D	0	2	C

Az orosz CryptoPro cég megírta saját "információs" RFC 4357 -ét . Eszerint a GOST R 34.11-94 megvalósításához az e cég által kifejlesztett S-box készletet kell használni. A jól ismert OpenSSL nyílt könyvtárban az 1.0.0-s verziótól kezdve a GOST R 34.11-94 hash függvény ezekkel a paraméterekkel plug-inként jelent meg. Ezeket a helyettesítő csomópontokat a Verba-O szoftver is használja [9]

Kimeneti formátum

A GOST szabvány szerint a hash függvény eredménye egy 256 bites szám. A szabvány nem határozza meg, hogyan kell kiadni. A különböző megvalósítások eltérő kimeneti formátumokat használnak, ami a két közös S-boxhoz társulva tovább növeli a zavart.

A GOST R 34.11-94 az "A függelékben" [7] Little-endian számokkal működik . Sok implementáció (nevezetesen rhash , mhash könyvtár, openssl konzol segédprogram ) a kapott hash 32 bájtját hexadecimális jelöléssel adja ki, a memóriában való tárolás sorrendjében – először alacsony bájtok. Ezt az ábrázolást az indokolja, hogy olyan széles körben elterjedt algoritmusok hash összegeinek származtatására használják, mint: MD5 , SHA-1 , Tiger , Whirlpool stb.

GOST("Ez az üzenet, hossza = 32 bájt") = B1C466D37519B82E8319819FF32595E047A28CB6F83EFF1C6916A815A637FFFA

A [7] szabványban megadott példákban az eredményül kapott hash egy 256 bites Little-endian szám hexadecimális reprezentációjaként van felírva. Ez fordított bájtsorrendet eredményez (a legjelentősebb bitek először). Ugyanezt a sorrendet használja különösen az OpenSSL könyvtár forrásaihoz tartozó gostsum program.

H=FAFF37A6 15A81669 1CFF3EF8 B68CA247 E09525F3 9F811983 2EB81975 D366C4B1

Példák

Részletes példa a szabványból

Számítsuk ki az "Ez üzenet, hossza=32 bájt" üzenet hash-ét egy "teszt" paraméterkészlettel.

Mivel az üzenet hossza 256 bit, nincs szükség nullák hozzáadására. Hexadecimális formában ezt az üzenetet bájtok sorozata képviseli

54 68 69 73 20 69 73 20 6D 65 73 73 61 67 65 2C 20 6C 65 6E 67 74 68 3D 33 32 20 62 79 74 65 73

Ezt a sorozatot Little-endian 256 bites számként kezeljük

M = 0x73657479622032333D6874676E656C202C6567617373656D2073692073696854

Kiszámoljuk : $H_{2}=f(H_{1},M)$

Kulcsgenerálás

K 1 =0x733D2C20 65686573 74746769 79676120 626E7373 20657369 326C6568 33206D54 K 2 =0x110C733D 0D166568 130E7474 06417967 1D00626E 161A2065 090D326C 4D393320 K 3 =0x80B111F3 730DF216 850013F1 C7E1F941 620C1DFF 3ABAE91A 3FA109F2 F513B239 K 4 =0xA0E2804E FF1B73F2 ECE27A00 E7B8C7E1 EE1D620C AC0CC5BA A804C05E A18B0AEC

Titkosítás átalakítás

S 1 = 0x42ABBCCE 32BC0B1B S 2 = 0x5203EBC8 5D9BCFFD S 3 = 0x8D345899 00FF0E28 S 4 = 0xE7860419 0D2A562D S=0xE7860419 0D2A562D 8D345899 00FF0E28 5203EBC8 5D9BCFFD 42ABBCCE 32BC0B1B

Véletlenszerű átalakítás

H 2 =0xCF9A8C65 505967A4 68A03B8C 42DE7624 D99C4124 883DA687 561C7DE3 3315C034

Kiszámoljuk : $H_{3}=f(H_{2},L)$

L = 0x00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000100

Kulcsgenerálás

K 1 =0xCF68D956 9AA09C1C 8C3B417D 658C24E3 50428833 59DE3D15 6776A6C1 A4248734 K 2 =0x8FCF68D9 809AA09C 3C8C3B41 C7658C24 BB504288 2859DE3D 666676A6 B3A42487 K 3 =0x4E70CF97 3C8065A0 853C8CC4 57389A8C CABB50BD E3D7A6DE D1996788 5CB35B24 K 4 =0x584E70CF C53C8065 48853C8C 1657389A EDCABB50 78E3D7A6 EED19867 7F5CB35B

Titkosítás átalakítás

S=0x66B70F5E F163F461 468A9528 61D60593 E5EC8A37 3FD42279 3CD1602D DD783E86

Véletlenszerű átalakítás

H 3 =0x2B6EC233 C7BC89E4 2ABC2692 5FEA7285 DD3848D1 C6AC997A 24F74E2B 09A3AEF7

Kiszámoljuk : $H_{4}=f(H_{3},\Sigma \ )$

\Sigma\

= 0x73657479622032333D6874676E656C202C6567617373656D2073692073696854

Kulcsgenerálás

K 1 =0x5817F104 0BD45D84 B6522F27 4AF5B00B A531B57A 9C8FDFCA BB1EFCC6 D7A517A3 K 2 =0xE82759E0 C278D95E 15CC523C FC72EBB6 D2C73DA8 19A6CAC9 3E8440F5 C0DDB66A K 3 =0x77483AD9 F7C29CAA EB06D1D7 641BCAD3 FBC3DAA0 7CB555F0 D4968080 0A9E56BC K 4 =0xA1157965 2D9FBC9C 088C7CC2 46FB3DD2 7681ADCB FA4ACA06 53EFF7D7 C0748708

Titkosítás átalakítás

S=0x2AEBFA76 A85FB57D 6F164DE9 2951A581 C31E7435 4930FD05 1F8A4942 550A582D

Keverő transzformációt alkalmazva megkapjuk a hash eredményét:

H 4 =0xFAFF37A6 15A81669 1CFF3EF8 B68CA247 E09525F3 9F811983 2EB81975 D366C4B1

Egy adott Little-endian szám a gép memóriájában bájtok sorozataként jelenik meg:

B1 C4 66 D3 75 19 B8 2E 83 19 81 9F F3 25 95 E0 47 A2 8C B6 F8 3E FF 1C 69 16 A8 15 A6 37 FF FA

Az "alsó bájtok először" rekordban van

GOST("Ez az üzenet, hossza = 32 bájt") = B1C466D37519B82E8319819FF32595E047A28CB6F83EFF1C6916A815A637FFFA

Második példa a szabványból

Big - endian ábrázolásban

M = 0x7365747962203035203D206874676E656C20736168206567617373656D206C616E696769726F2065687420657075577 H=0x0852F5623B89DD57AEB4781FE54DF14EEAFBC1350613763A0D770AA657BA1A47

Ugyanez a példa a Little-endianban

GOST("Tegyük fel, hogy az eredeti üzenet hossza = 50 bájt") = 471ABA57A60A770D3A76130635C1FBEA4EF14DE51F78B4AE57DD893B62F55208

Egyéb példák

Példák [10] ebben a részben az mhash , RHash , ReHash által használt little-endian reprezentációban adják meg .

GOST hash "teszt" paraméterkészlettel

GOST("") = CE85B99CC46752FFFEE35CAB9A7B0278ABB4C2D2055CFF685AF4912C49490F8D GOST("a") = D42C539E367C66E9C88A801F6649349C21871B4344C6A573F849FDCE62F314DD GOST("abc") = F3134348C44FB1B2A277729E2285EBB5CB5E0F29C975BC753B70497C06A4D51D GOST ("üzenetkivonat") = AD4434ECB18F2C99B60CBE59EC3D2469582B65273F48DE72DB2FDE16A4889A4D GOST (128 karakter "U") = 53A3A3ED25180CEF0C1D85A074273E551C25660A87062A52D926A9E8FE5733A4 GOST (1000000 karakter "a") = 5C00CCC2734CDD3332D3D4749576E3C1A7DBAF0E7EA74E9FA602413C90A129FA

Az üzenet legkisebb változása az esetek túlnyomó többségében egészen más hash-hez vezet a lavinahatás miatt . Például, ha a következő kifejezésben a kutyát fogaskerékre változtatja, a következőt kapja:

GOST(" A gyors barna róka átugrik a lusta kutyán ") = 77B7FA410C9AC58A25F49BCA7D0468C9296529315EACA76BD1A10F376D1F4294 GOST("A gyors barna róka átugrik a lusta fogaskeréken") = A3EBC4DAAAB78B0BE131DAB5737A7F67E602670D543521319150D2E14EEEC445

CryptoPro paraméterkészlet

GOST("") = 981E5F3CA30C841487830F84FB433E13AC1101569B9C13584AC483234CD656C0 GOST("a") = E74C52DD282183BF37AF0079C9F78055715A103F17E3133CEFF1AACF2F403011 GOST("abc") = B285056DBF18D7392D7677369524DD14747459ED8143997E163B2986F92FD42C GOST("üzenetkivonat") = BC6041DD2AA401EBFA6E9886734174FEBDB4729AA972D60F549AC39B29721BA0 GOST("A gyors barna róka átugrik a lusta kutyán") = 9004294A361A508C586FE53D1F1B02746765E71B765472786E4770D565830A76 GOST("Ez az üzenet, hossza = 32 bájt") = 2CEFC2F7B7BDC514E18EA57FA74FF357E7FA17D652C75F69CB1BE7893EDE48EB GOST("Tegyük fel, hogy az eredeti üzenet hossza = 50 bájt") = C3730C5CBCCACF915AC292676F21E8BD4EF75331D9405E5F1A61DC3130A65011 GOST(128 karakter "U") = 1C4AC7614691BBF427FA2316216BE8F10D92EDFD37CD1027514C1008F649C4E8 GOST(1000000 karakter "a") = 8693287AA62F9478F7CB312EC0866B6C4E4A0F11160441E8F4FFCD2715DD554F

A kriptográfiai erősség értékelése

2008- ban Ausztriából és Lengyelországból álló szakértőkből álló csapat olyan technikai sebezhetőséget fedezett fel, amely 223 -szorosára csökkentette az ütközések észlelését . [11] [12] Az ütközés megtalálásához szükséges műveletek száma tehát 2 105 , ami azonban jelenleg gyakorlatilag nem valósítható meg. Ütközéses támadás végrehajtásának a gyakorlatban csak a dokumentumok digitális aláírása esetén van értelme, sőt, ha a hacker az aláíratlan eredetit módosítani tudja.

Használat

A funkciót a GOST R 34.10-2001 szabvány szerinti aszimmetrikus titkosítási algoritmuson alapuló digitális aláírási rendszerek implementálásakor használják . Az orosz CIPF fejlesztők közössége megállapodott az interneten használt paraméterekről a GOST R 34.11-94-ben, lásd az RFC 4357 -et .

Nyilvános kulcsok használata a tanúsítványokban . [13]
Használja az üzenetek védelmére S/MIME -ben ( kriptográfiai üzenetszintaxis , PKCS#7 ). [tizennégy]
Használja a kapcsolatok biztosítására TLS -ben ( SSL , HTTPS , WEB ). [tizenöt]
Az üzenetek XML-aláírással ( XML-titkosítás ) biztosítására használható. [16]
Az internetes címek és nevek integritásának védelme ( DNSSEC ). [17]

Jegyzetek

↑ A Rosstandart parancsa, 2012. augusztus 7-i 216-st . Hozzáférés dátuma: 2013. május 31. Az eredetiből archiválva : 2016. március 4. (határozatlan)
↑ "... meg kell jegyezni, hogy a nemzeti szabvány eltörlése a kriptográfiai információvédelem területén nem alapja a jelen szabvány által meghatározott algoritmusokat megvalósító CIPF-tanúsítvány felfüggesztésének vagy visszavonásának..." TK26 (elérhetetlen link ) . Letöltve: 2013. május 31. Az eredetiből archiválva : 2013. december 7.. (Orosz)
↑ A. V. Voylukov. Az Orosz Föderáció Központi Bankjának 1995. január 31-i, N 02-13. számú rendelete „Az Orosz Föderáció állami normáinak az Orosz Föderáció Központi Bankja rendszerében történő hatályba lépéséről” (hozzáférhetetlen link - történelem ) (1995. január 31.). - Az Orosz Föderáció Központi Bankjának 02-13. Letöltve: 2019. január 21. (Orosz)
↑ A Rosstandart parancsa, 2012. augusztus 7-i 216-st . Letöltve: 2020. január 11. Az eredetiből archiválva : 2020. január 11. (határozatlan)
↑ A Rosstandart 2018. december 4-i rendelete, 1060-st . Letöltve: 2020. január 11. Az eredetiből archiválva : 2020. január 11. (határozatlan)
↑ Ukrajna Speciális Kommunikációs Állami Szolgálatának 2019. november 19-i 3563/5/610 számú végzése . Letöltve: 2020. január 11. Az eredetiből archiválva : 2020. január 11. (határozatlan)
↑ 1 2 3 GOST R 34.11-94, A FÜGGELÉK (1994. május 23.). Letöltve: 2010. október 28. Az eredetiből archiválva : 2012. március 2.. (Orosz)
↑ Schneier B. 14.1 GOST // Alkalmazott kriptográfia. Protokollok, algoritmusok, forráskód C nyelven = Applied Cryptography. Protokollok, algoritmusok és forráskód: C. - M . : Triumf, 2002. - S. 373-377. — 816 p. - 3000 példányban. - ISBN 5-89392-055-4 .
↑ Algoritmusok kriptográfiai paramétereinek azonosítói . Letöltve: 2020. február 21. Az eredetiből archiválva : 2013. július 28. (határozatlan)
↑ Tesztvektorok GOST R 34.11-94 Archív másolat 2013. március 30-án a Wayback Machine -nél (orosz)
↑ Európai kriptológusok megtámadják a hash függvényeket Archiválva : 2008. szeptember 1. a Wayback Machine -nél
↑ "A GOST hash-függvény kriptoanalízise", PDF (nem elérhető link) Számítástechnikai előadási jegyzetek, 2008, 5157/2008. kötet, 162-178, DOI: 10.1007/978-3-540-85174-5_1
↑ Leontiev, S., Szerk. és D. Shefanovskij, szerk. A GOST R 34.10-94, GOST R 34.10-2001 és GOST R 34.11-94 algoritmusok használata az Internet X.509 nyilvános kulcsú infrastruktúra-tanúsítvánnyal és CRL-profillal ( 2006. május). — RFC 4491 . Letöltve: 2009. június 12. Az eredetiből archiválva : 2012. február 22..
↑ Leontiev, S., Szerk. és G. Chudov, szerk. A GOST 28147-89, GOST R 34.11-94, GOST R 34.10-94 és GOST R 34.10-2001 algoritmusok kriptográfiai üzenetszintaxissal (CMS) használatával ( 2006. május). — RFC 4490 . Letöltve: 2009. június 12. Az eredetiből archiválva : 2011. augusztus 24..
↑ Leontiev, S., Szerk. és G. Chudov, szerk. GOST 28147-89 Cipher Suite for Transport Layer Security (TLS) ( 2008. december). — Internet-tervezetek, munka folyamatban. Letöltve: 2009. június 12. Az eredetiből archiválva : 2011. augusztus 24..
↑ S. Leontyev, P. Szmirnov, A. Cselpanov. GOST 28147-89, GOST R 34.10-2001 és GOST R 34.11-94 algoritmusok használata az XML biztonsághoz ( 2008. december). — Internet-tervezetek, munka folyamatban. Letöltve: 2009. június 12. Az eredetiből archiválva : 2011. augusztus 24..
↑ V. Dolmatov, Szerk. GOST aláírási algoritmusok használata a DNSKEY és RRSIG erőforrásrekordokban a DNSSEC -hez ( 2009. április). — Internet-tervezetek, munka folyamatban. Letöltve: 2009. június 12. Az eredetiből archiválva : 2012. február 22..

Linkek

A GOST R 34.11-94 „Információs technológia. Az információk kriptográfiai védelme. Hash függvény"
A GOST 34.311-95 „Információs technológia. Az információk kriptográfiai védelme. Hash függvény"
GOST R 34.11 - 94. Kivonatoló funkció. Rövid elemzés.

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