Bælte

Den aktuelle version af siden er endnu ikke blevet gennemgået af erfarne bidragydere og kan afvige væsentligt fra den version , der blev gennemgået den 25. maj 2019; checks kræver 35 redigeringer .

Bælte
Oprettet	2001 _
offentliggjort	2007 _
Nøglestørrelse	256 bit
Blokstørrelse	128 bit
Antal runder	otte
Type	kombination af Feistel-netværk og en: Lai-Massey-skema

BelT er den statslige standard for symmetrisk kryptering og integritetskontrol i Republikken Hviderusland. Standardens fulde navn er STB 34.101.31-2007 “Informationsteknologi og sikkerhed. Kryptografiske algoritmer til kryptering og integritetskontrol. Vedtaget som en foreløbig standard i 2007. Indført som den endelige standard i 2011.

Beskrivelse

BelT er en blokchiffer med en 256-bit nøgle og 8 kryptotransformationscyklusser, der opererer med 128-bit ord. Standardens kryptografiske algoritmer er bygget på basis af grundlæggende krypteringstilstande for datablokke. Alle standardalgoritmer er opdelt i 8 grupper:

krypteringsalgoritmer i simpel udskiftningstilstand ;
krypteringsalgoritmer i blokkædetilstand ;
krypteringsalgoritmer i gamma-tilstand med feedback ;
krypteringsalgoritmer i tællertilstand ;
algoritme til generering af simuleret indsættelse;
Algoritmer til samtidig kryptering og efterligningsbeskyttelse af data;
Algoritmer til samtidig kryptering og imitationsbeskyttelse af nøgler;
hashing- algoritme ;

De første fire grupper er til sikker meddelelse. Hver gruppe inkluderer en krypteringsalgoritme og en dekrypteringsalgoritme baseret på en hemmelig nøgle. Parter med en delt nøgle kan udveksle meddelelser ved at kryptere dem, før de sendes, og dekryptere dem, efter de er modtaget. I tilstandene med simpel udskiftning og sammenkædning af blokke krypteres meddelelser, der indeholder mindst en blok, og i gammatilstandene med feedback og tælleren krypteres meddelelser af vilkårlig længde.

Den femte algoritme er designet til at kontrollere integriteten af meddelelser ved hjælp af imiterede inserts - kontrolord, der bestemmes ved hjælp af en hemmelig nøgle. Parter, der har en fælles nøgle, kan organisere integritetskontrol under udvekslingen af beskeder ved at tilføje falske indstik til dem, når de sender og kontrollere falske indstik ved modtagelse. Kontrol af efterlignede indstik tillader desuden modtagersiden at verificere, at afsendersiden kender den hemmelige nøgle, det vil sige at verificere ægtheden af meddelelser.

I den sjette gruppe er det oprindelige budskab givet af to dele: åben og kritisk. Beskyttelsesalgoritmerne er designet til at kontrollere integriteten af begge dele og sikre fortroligheden af den kritiske del. Når beskyttelse er indstillet, beregnes den imiterede indsættelse af hele meddelelsen, og dens kritiske del krypteres. Når beskyttelsen fjernes, kontrolleres efterligningen, og hvis kontrollen lykkes, dekrypteres den kritiske del.

I algoritmerne i den syvende gruppe skal længden af den beskyttede meddelelse kendes med det samme; disse algoritmer anbefales at blive brugt til at beskytte nøgler. Den beskyttede nøgle er ledsaget af en offentlig header, der indeholder nøglens offentlige attributter og er også en kontrolværdi for integritetskontrol. Der kan anvendes faste vedvarende overskrifter, som kun tjener som integritetstjek. Når beskyttelse er indstillet, krypteres nøglen sammen med dens overskrift. Når beskyttelsen fjernes, udføres den omvendte transformation, og den dekrypterede header sammenlignes med kontrolheaderen.

Den ottende algoritme er designet til at beregne hashværdier - kontrolord, der bestemmes uden brug af en nøgle. Parter kan organisere meddelelsesintegritetstjek ved at sammenligne deres hashværdier med gyldige kontrolhashværdier. Ændring af en besked med stor sandsynlighed ændrer den tilsvarende hashværdi, og derfor kan hashværdier bruges i stedet for selve beskederne, for eksempel i elektroniske digitale signatursystemer.

Bloker kryptering

Input og output

Indgangsdataene for krypterings- og dekrypteringsalgoritmerne er blokken og nøglen $X\in \{0,1\}^{128}$ $\theta \in \{0,1\}^{256}.$

Outputtet er en blok - resultatet af kryptering eller dekryptering af ordet på nøglen eller $Y\in \{0,1\}^{128}$ $x$ $\theta :Y=F_{\theta }(X)$ $Y=F_{\theta }^{-1}(X).$

Indgangsdataene til kryptering er forberedt som følger:

Ordet er skrevet som $x$ $X=X_{1}\|X_{2}\|X_{3}\|X_{4},X_{i}\in \{0,1\}^{32}.$
Nøglen skrives i formen , og urtasterne bestemmes $\theta$ $\theta =\theta _{1}\|\theta _{2}\|\theta _{3}\|\theta _{4}\|\theta _{5}\|\theta _{ 6}\|\theta _{7}\|\theta _{8},\theta _{i}\i \{0,1\}^{32}$ $K_{1}=\theta _{1},K_{2}=\theta _{2},K_{3}=\theta _{3},K_{4}=\theta _{4} ,K_{5}=\theta _{5},K_{6}=\theta _{6},K_{7}=\theta _{7},K_{8}=\theta _{8},K_ {9}=\theta _{1},......,K_{56}=\theta _{8}.$

Notation og hjælpetransformationer

Transform sætter i linje ord , ord $G_{r}:\{0,1\}^{32}\højrepil \{0,1\}^{32}$ $u=u_{1}\parallel u_{1}\parallel u_{2}\parallel u_{3}\parallel u_{4},u_{i}\in \{0,1\}^{8 }$

$G_{r}(u)=RotHi^{r}(H(u_{1})\parallel H(u_{2})\parallel H(u_{3})\parallel H(u_{4} )).$

$RotHi^{r}-$ cyklisk venstreskift efter lidt. $r$

$H(u)-$ operationen med at erstatte en 8-bit inputstreng med en substitution fra tabel 1.

Substitutionen er givet af en fast tabel. Tabellen bruger hexadecimal repræsentation af ord $H:\{0,1\}^{8}\højrepil \{0,1\}^{8}$ $u\in \{0,1\}^{8}.$

$\box plus$ og modulo additions- og subtraktionsoperationer $\boxminus-$ $2^{32}.$

Kryptering

For at kryptere en blok på en nøgle udføres følgende trin: $x$ $\theta$

Installere $a\leftarrow X_{1},b\leftarrow X_{2},c\leftarrow X_{3},d\leftarrow X_{4}.$
For = 1,2,...,8 gør: $jeg$

en)

b\leftarrow b\oplus G_{5}(a\boxplus K_{7i-6});

c\leftarrow c\oplus G_{21}(d\boxplus K_{7i-5});

a\leftarrow a\boxminus G_{13}(b\boxplus K_{7i-4});

fire)

e\leftarrow G_{21}(b\boxplus c\boxplus K_{7i-3})\oplus \langle i\rangle _{32};

b\leftarrow b\boxplus e;

c\leftarrow c\boxminus e;

d\leftarrow d\boxplus G_{13}(c\boxplus K_{7i-2});

otte)

b\leftarrow b\oplus G_{21}(a\boxplus K_{7i-1});

c\leftarrow c\oplus G_{5}(d\boxplus K_{7i});

ti)

a\leftrightarrow b;

elleve)

c\leftrightarrow d;

12)

b\leftrightarrow c;

3. Installer

Y\leftarrow b\|d\|a\|c.

4. Retur

Y.

Dekryptering

For at dekryptere en blok på en nøgle udføres følgende trin: $x$ $\theta$

Installere $a\leftarrow X_{1},b\leftarrow X_{2},c\leftarrow X_{3},d\leftarrow X_{4}.$
For 8,7,...,1 løb: $i=$

en)

b\leftarrow b\oplus G_{5}(a\boxplus K_{7i});

c\leftarrow c\oplus G_{21}(d\boxplus K_{7i-1});

a\leftarrow a\boxminus G_{13}(b\boxplus K_{7i-2});

fire)

e\leftarrow G_{21}(b\boxplus c\boxplus K_{7i-3})\oplus \langle i\rangle _{32};

b\leftarrow b\boxplus e;

c\leftarrow c\boxminus e;

d\leftarrow d\boxplus G_{13}(c\boxplus K_{7i-4});

otte)

b\leftarrow b\oplus G_{21}(a\boxplus K_{7i-5});

c\leftarrow c\oplus G_{5}(d\boxplus K_{7i-6});

ti)

a\leftrightarrow b;

elleve)

c\leftrightarrow d;

12)

a\leftrightarrow d;

3. Installer

Y\leftarrow c\|a\|d\|b.

4. Retur

Y.

Udvikling af imiteret indsættelse

Input data

En indledende meddelelse af vilkårlig længde, repræsenteret som en bitsekvens . Hvis er et ikke-tomt ord, så skriv det i formen: . Hvis er tom, så og . $X\in \{0,1\}^{*}$ $x$ ${\displaystyle X=X_{1}\|X_{2}\|...\|X_{n)),|X_{1}|=|X_{2}|=...=| X_{n-1}|=128.0<|X_{n}|\leq 128$ $x$ $n=1$ $|X_{1}|=0$
Nøglen er en bitsekvens af længde 256. $\theta \in \{0,1\}^{256}$

Hjælpetransformationer og variabler

Konverteringer : der virker på en ord -bit-sekvens med længden 32. Hvori: ${\displaystyle \phi _{1},\phi _{2))$ ${\{0,1\}}^{128}\højrepil {\{0,1\}}^{128}$ ${\displaystyle u=u_{1}||u_{2}||u_{3}||u_{4},u_{i}\i \{0,1\}^{32))$

$\phi _{1}(u)=u_{2}||u_{3}||u_{4}||(u_{1}\oplus u_{2}),$

$\phi _{2}(u)=(u_{1}\oplus u_{4})||u_{1}||u_{2}||u_{3}.$

En mapping , der kortlægger en bitsekvens med en længde på mindre end 128 til et ord med en længde på 128. Handler i henhold til reglen: $\psi$

$\psi (u)=u||1||0^{127-|u|}$ .

Hjælpevariabler er bitsekvenser med en længde på 128. $r,s\in \{0,1\}^{256}$

Algoritme til generering af imitationsindsættelse

Udfyld hjælpevariablen med nuller: og indstil krypteringsresultatet på den givne nøgle til : . $s$ $s\leftarrow 0^{128}$ $s$ $\theta \in \{0,1\}^{256}$ $r$ $r\leftarrow F_{\theta }(s)$
For hver blok af inputmeddelelsen skal du udføre: . $i=1,2,...,n-1$ $s\leftarrow F_{\theta }(s\oplus X_{i})$
Hvis , så udfør , ellers . $|X_{n}|=128$ $s\leftarrow s\oplus X_{n}\oplus \phi _{1}(r)$ $s\leftarrow s\oplus \psi (X_{n})\oplus \phi _{2}(r)$
Skriv i de første 64 bit af ordet : . $T$ $F_{\theta }(s)$ $T\leftarrow L_{64}(F_{\theta }(s))$
Retur . $T$

Hashing-algoritme

Hashing-algoritmen bruges til at beregne en hashværdi, som senere kan bruges til at kontrollere dataenes integritet.

Input data

Inputtet til algoritmen er en besked af vilkårlig længde, repræsenteret som en bitsekvens . $X\in \{0,1\}^{*}$

Outputtet er et ord . $Y\in \{0,1\}^{256}$

For at algoritmen skal fungere, er den indledende bitsekvens polstret med nuller, så dens længde er delelig med 256 og er repræsenteret som følger: . Vi skal også bruge variabler og . $X=X_{1}||X_{2}||...||X_{d},X_{i}\in \{0,1\}^{256}$ $s\in \{0,1\}^{128}$ $h\in \{0,1\}^{256}$

Hjælpetransformationer

Lad der være et ord . $u=u_{1}||u_{2}||u_{3}||u_{4},u_{i}\in \{0,1\}^{128}$

Vi definerer to kortlægninger:

$\sigma _{1}:{\{0,1\}}^{512}\højrepil {\{0,1\}}^{128},$

$\sigma _{2}:{\{0,1\}}^{512}\højrepil {\{0,1\}}^{256},$

som handler på ordet efter reglerne: $u$

$\sigma _{1}(u)=F_{u_{1}||u_{2}}(u_{3}\oplus u_{4})\oplus u_{3}\oplus u_{4} ,$

$\sigma _{2}(u)=(F_{\theta _{1}}(u_{1})\oplus u_{1})||(F_{\theta _{2}}(u_ {2})\oplus u_{2}),$

hvor ,. _ ${\displaystyle \theta _{1}=\sigma _{1}(u)||u_{4))$ ${\displaystyle \theta _{2}=(\sigma _{1}(u)\oplus 1^{128})||u_{3))$

Beregning af en hashværdi

Algoritmen udføres i flere trin:

Vi udfylder variablen med nuller: . $s$ $s\longleftarrow 0^{128}$
Vi skriver de to første rækker i substitutionstabellen til variablen , flytter fra venstre mod højre og fra top til bund: . $h$ $H$ ${\displaystyle h\longleftarrow B194BAC80A08F53B366D008E584A5DE48504FA9D1BB6C7AC252E72C202FDCE0D_{16))$
For hver blok skal du udføre følgende handlinger: $X_{i},i={\overline {1,d))$
1. $s\venstrepil s\oplus \sigma _{1}(X_{i}\|h)$ ;
2. $h\venstrepil \sigma _{2}(X_{i}||h)$ .
Vi beregner :. $Y$ $Y\longleftarrow \sigma _{2}(\langle |X|\rangle _{128}||s||h)$
Vi returnerer den modtagne værdi , som er hashværdien af kildeteksten . $Y$ $x$

Links

Symmetriske kryptosystemer
Stream-cifre	A3 A5 A8 Decim F-FCSR Korn HC-256 KCipher-2 MICKEY MUGI GEDD Phelix RC4 Kanin FORSEGLE SNE SOSEMANUK Salsa 20 STRUMOK Trivium VMPC
Feistel netværk	GOST 28147-89 (Magma) blæsefisk Camellia CAST-128 CAST-256 CIFERUNIKORN-A CIFERUNIKORN-E CLEFIA Cobra DEL DES DESX DFC E2 ENRUPT FEAL HPC IDE KASUMI Khafre Khufu LOKI97 MacGuffin MARS MESH MISTY1 NyDES NDS RC5 RC6 FRØ Simon Sinople skipjack SM4 Speck TE XTEA XXTEA Raiden RTEA Triple DES To fisk
SP netværk	Græshoppe 3 vejs ABC ARIA AES (Rijndael) Akelarre Anubis BaseKing Bas Omatic Bælte CRYPTON Diamant 2 grand cru Hierocrypt-3 Hierocrypt-L1 KHAZAD Kalyna Lucifer til stede Regnbue SIKRERE HAJ FIRKANT Slange tre fisk
Andet	FRØ NUSH REDOC SC2000 SHACAL CS-Cipher

Hash funktioner
generelle formål	Adler-32 CRC Fletcher kontrolsum FNV MurmurHash2 MurmurHash2A MurmurHash3 PJW-32 TTH - Hash Tree jenkins hash hash sum
Kryptografisk	Stribog GOST R 34,11-94 Bælte BLAKE bmw CubeHash EKKO edonkey2k FSB Fuge 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 Hud Snefru Tiger Whirlpool
Nøglegenereringsfunktioner	bcrypt PBKDF2 krypt Argon 2 Lyra2
Tjek nummer ( sammenligning )	Tjek sum Verhouffs algoritme Månen algoritme Damm algoritme Stregkode bankkonti bankkort ER I SNILS OKPO TIN OKATO ISBN OGRN og OGRNIP VIN
Hashes	Sammenligning af checknumre Autentificeringsprotokoller Stregkode sammenligning Kryptografi Magnet link Merkle signatur ed2k URNE