NUSH

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 10. juni 2016; checks kræver 12 redigeringer .

NUSH
Skaber	Anatoly Lebedev , Alexey Volchkov
Oprettet	1999 _
offentliggjort	2000 _
Nøglestørrelse	128, 192, 256 bit
Blokstørrelse	64, 128, 256 bit
Antal runder	36, 68, 132

NUSH ("Vores") er en bloksymmetrisk krypteringsalgoritme udviklet af Anatoly Lebedev og Alexei Volchkov for det russiske firma LAN Crypto.

NUSH har flere forskellige varianter, der har forskellige blokstørrelser (64, 128, 256 bit), forskelligt antal runder (36, 128 eller 132 runder afhængig af blokstørrelsen) og bruger en nøglelængde på 128, 192 eller 256 bit. Algoritmen bruger ikke S-bokse, men kun operationer som AND, OR, XOR, modulo addition og cykliske skift. Før første og efter sidste runde udføres en "blegning" af nøglen.

Denne algoritme blev fremsat i NESSIE-projektet , men blev ikke valgt, fordi det blev vist, at lineær kryptoanalyse kan være mere effektiv end et brute-force-angreb.

Andre algoritmer kan bygges på basis af krypteringsalgoritmen. Flere af dem præsenteres i denne artikel.

Beskrivelse af algoritmen

Kryptering

Lad os introducere notation. Lad være længden af den krypterede klartekstblok . (startnøgle) - valgt efter et eller andet skema baseret på nøglen K. Bitvis tilføjet til kildeteksten: Derefter opstår r-1 runder, givet ved følgende ligninger, hvori (Rund undernøgle) - runde undernøgler, # - bitvise konjunktion eller disjunktion , vælges i henhold til skemaet, , er kendte konstanter, >>>j er et cyklisk skift til højre med j bit: $N=4n$ ${\displaystyle P=P_{3}P_{2}P_{1}P_{0))$ ${\displaystyle KS_{i))$ $a_{0}b_{0}c_{0}d_{0}=P_{3}P_{2}P_{1}P_{0}\oplus KS_{0}KS_{1}KS_{2} KS_{3}$ ${\displaystyle KR_{i))$ $C_{i}$ $S_{i}$

for i=1…(r-1)

$a_{i}=b_{i-1}$

${\displaystyle b_{i}=((c_{i}\oplus (KR_{i-1}+C_{i-1}))+b_{il})>>>S_{i-1))$

$c_{i}=d_{i-1}$

$d_{i}=a_{i-1}+(b_{i}\#d_{il})$

Den sidste iteration adskiller sig kun fra de vigtigste ved fraværet af en permutation efter evaluering af udtrykkene på højre side af lighederne:

$a_{r}=a_{r-1}+(c_{r}\#d_{r-1})$

$b_{r}=b_{r-1}$

$c_{r}=((c_{r-1}\oplus (KR_{r-1}+C_{r-1}))+b_{r-1})>>>S_{r-1 }$

$d_{r}=d_{r-1}$

Output: krypteret blok $M_{0}M_{1}M_{2}M_{3}=a_{r}b_{r}c_{r}d_{r}\oplus KF_{0}KF_{1}KF_{2} KF_{3}$

Dekryptering

Ifølge den generelle formel for invertering af produktet af operatører er der også konstrueret en dekrypteringsprocedure. $(AB)^{-1}=B^{-1}A^{-1}$

$a_{r}b_{r}c_{r}d_{r}=M_{0}M_{1}M_{2}M_{3}\oplus KF_{0}KF_{1}KF_{2} KF_{3}$

Én dekrypteringsiteration udføres:

${\displaystyle d_{r-1}=d_{r))$

${\displaystyle b_{r-1}=b_{r))$

$a_{r-1}=a_{r}-(c_{r}\#d_{r-1})$

$c_{r-1}=c_{r}>>>(n-S_{r-1})$ ( -længde , du kan udføre et cyklisk skift til venstre ved at ) $n=N/4$ $c_{r}$ ${\displaystyle S_{r-1))$

$c_{r-1}=c_{r-1}-KR_{r-1}-b_{r-1}$

Derefter er den vigtigste dekrypteringscyklus, bestående af iterationer, heller ikke væsentlig forskellig fra den forrige:

for i=r-1…1

$d_{i-1}=c_{i}$

$b_{i-1}=a_{i}$

$a_{i-1}=d_{i}-(b_{i}\#c_{i-1})$

$c_{i-1}=(b_{i}>>>(n-S_{i-1}))-KR_{i-1}-a_{i-1}$

Kommentarer

Nogle kilder mener, at krypteringsproceduren består af 4 gange færre runder, bestående af 4 iterationer af ovennævnte type (uden indledende og sidste addition modulo 2). Så forfatterne af chifferen skrev selv deres algoritme som følger:

Vi definerede funktionen R - "iteration":

${\displaystyle R(a,b,c,d,k,s)=a_{1}b_{1}c_{1}d_{1))$

$c_{1}=(c+k+b)>>>s$

$a_{1}=a+c_{1}\#d$

$b_{1}=b$

$d_{1}=d$

Beskrev den indledende transformation (addition ("+") med KS)
Runden siges at bestå af 4 iterationer:

$R(a,b,c,d,k_{1},s_{1})$

$R(b,c,d,a,k_{2},s_{2})$

$R(c,d,a,b,k_{3},s_{3})$

$R(d,a,b,c,k_{4},s_{4})$

hvor - den tilsvarende konstant tilføjes til iterationsnøglen ${\displaystyle k_{i}=k_{i}+C_{i))$ $k_i$ $C_{i}$

De beskrev den endelige transformation (addition ("+") med KF).

Algoritmerne ligner hinanden, da "+"-operationen er defineret af forfatterne separat fra hovedbeskrivelsen af krypteringsmetoden. Det skal bemærkes, at skemaet for "+" operationer kan ændres ved at vælge reversible binære operationer på vektorer med længde . Den ikke-lineære operation af almindelig addition med ignorering af overløb er beregnet til at komplicere lineær kryptoanalyse. Og XOR-operationen hjælper med at undgå differentiel kryptoanalyse . I det følgende vil vi overveje den første beskrivelse af algoritmen givet i en artikel af kinesiske matematikere, der udførte en lineær kryptoanalyse af algoritmen. $n$

Valget af "+" operationer blev foretaget på baggrund af resultaterne af forskning om parallelisering af beregninger på Pentium-type processorer. Valget af at ændre rækkefølgen af registre a, b, c, d fra rund til rund fremskynder forekomsten af diffusion og forvirring. Grundlæggende operationer (XOR, modulo addition , OR, AND) og deres rækkefølge fremskynder udførelsen af algoritmen implementeret i C på de fleste platforme, og implementeringen af algoritmen i assembler er ret kort. $2^{n}$

Nem implementering

Fra ovenstående beskrivelse er det klart, at for implementeringen af algoritmen er det nødvendigt:

Definer konstanter $C_{i}$
Kend tidsplanen for operationer #, nøgler.
Implementer:
- lidt skift til højre,
- addition og subtraktion af hele tal,
- bitvis XOR,
- bitvis disjunktion og konjunktion.

Samtidig er der ingen substitutionstabeller, der er til stede, for eksempel i GOST, og runden består af 6 operationer. Det faktum, at skiftet udføres af en tidligere kendt værdi, som ikke afhænger af hverken klartekst eller nøgle, forenkler i høj grad implementeringen af algoritmen på mikrokredsløb. Algoritmens enkelhed gør det nemt at kontrollere, at der ikke er en såkaldt "bagdør" i en bestemt implementering.

Indstillinger

Konstanter og $C_{i}$ $S_{i}$

N bloklængden er 64 bit

Der spilles 36 runder

jeg	$C_{i}$	jeg	$C_{i}$	jeg	$C_{i}$	jeg	$C_{i}$
0	ac25	9	6a29	atten	96 da	27	d25e
en	8a93	ti	6d84	19	905f	28	a926
2	243d	elleve	34 bd	tyve	d631	29	1c7b
3	262e	12	a267	21	aa62	tredive	5f12
fire	f887	13	cc15	22	4d15	31	4ecc
5	c4f2	fjorten	04fe	23	70 cb	32	3c86
6	8e36	femten	b94a	24	7533	33	28db
7	9fa1	16	df24	25	45fc	34	fc01
otte	7dc0	17	40ef	26	5337	35	7cb1

jeg	$S_{i}$	jeg	$S_{i}$	jeg	$S_{i}$	jeg	$S_{i}$
0	fire	9	2	atten	5	27	13
en	7	ti	9	19	en	28	12
2	elleve	elleve	fire	tyve	2	29	3
3	otte	12	13	21	fire	tredive	6
fire	7	13	en	22	12	31	elleve
5	fjorten	fjorten	fjorten	23	3	32	7
6	5	femten	6	24	9	33	femten
7	fire	16	7	25	2	34	fire
otte	otte	17	12	26	elleve	35	fjorten

Blokke er 128 bit lange

Med en bloklængde på 128 bit spilles 68 runder. Derfor 68 32-bit konstanter og 68 . $C_{i}$ $0<=S_{i}<=31$

Bloklængde 256 bit

Med en bloklængde på 256 bit spilles der 132 runder. Derfor 132 64-bit konstanter og 132 . $C_{i}$ $0<=S_{i}<=63$

Nøgleskema

Nøglen er repræsenteret som en sammenkædning af N/4-bit ord. KS og KF er sat vilkårligt, og det hele $K=K_{0}K_{1}...$ $K_{i}$

128-bit nøgle Bloker i 64 bit

Nøgle K er opdelt i 8 ord $KS_{0}=K_{4},\ KF_{0}=K_{3},\ KS_{1}=K_{5},\ KF_{1}=K_{2},$ $KS_{2}=K_{6},\ KF_{2}=K_{1},\ KS_{3}=K_{7},\ KF_{3}=K_{0},\ KR_{i }=K_{i\ mod\ 8},\ i=0...35$

Blokkere i 128 bit og 256 bit

K-tasten er opdelt i henholdsvis 4 og 2 ord, så de runde tangenter gentages med en periode på 4 eller 2. I sidstnævnte tilfælde er der det samme blandt KS og KF.

192-bit nøgle

Afhængigt af blokkens længde er nøglen opdelt i 12, 6 og 3 n-bit dele, som bestemmer gentagelsesperioden for de runde tangenter.

256-bit nøgle

Her er nøglen foreningen af 16, 8 eller 4 binære ord.

Driftsplan #

jeg	#	jeg	#	jeg	#	jeg	#
0	OG	16	ELLER	32	ELLER	48	OG
en	ELLER	17	ELLER	33	ELLER	49	OG
2	OG	atten	OG	34	OG	halvtreds	OG
3	ELLER	19	OG	35	ELLER	51	OG
fire	ELLER	tyve	OG	36	ELLER	52	OG
5	ELLER	21	OG	37	OG	53	OG
6	ELLER	22	OG	38	ELLER	54	ELLER
7	ELLER	23	ELLER	39	OG	55	OG
otte	OG	24	OG	40	ELLER	56	ELLER
9	ELLER	25	ELLER	41	OG	57	ELLER
ti	ELLER	26	ELLER	42	OG	58	ELLER
elleve	OG	27	ELLER	43	ELLER	59	OG
12	ELLER	28	OG	44	ELLER	60	OG
13	OG	29	ELLER	45	OG	61	OG
fjorten	ELLER	tredive	OG	46	OG	62	ELLER
femten	ELLER	31	OG	47	OG	63	ELLER

For yderligere iterationer gentages alt: ${\displaystyle \#_{i}=\#_{i\ mod\ 64))$

Ydeevne

Algoritmen indeholder ikke operationer med bitkompleksitet højere end , hvor er bitlængden af modulet eller operanderne (f.eks. moduloprodukt, at finde det inverse (ved multiplikation) element eller den største fælles divisor har bitkompleksitet , og eksponentiering har bit kompleksitet ). Derfor er det naturligt at forvente en høj hastighed på algoritmen. Forfatterne giver følgende data: $Okay)$ $k$ $O(k^{2})$ $O(k^3)$

Blokstørrelse, bit	C program		Samlingsprogram
Blokstørrelse, bit	Ure pr. blok	Ure pr. byte	Ure pr. blok	Ure pr. byte
64	180	23	130	17
128	340	22	250	16

Sikkerhed

Hovedårsagen til elimineringen af NUSH-algoritmen i NESSIE-konkurrencen var algoritmens sårbarhed over for lineær kryptoanalyse fundet af Wu Wenling og Feng Dengo.

I deres artikel "Linear cryptanalysis of the NUSH block cipher" bruger de begrebet angrebskompleksitet , hvor det karakteriserer behovet for hukommelse og - for mængden af beregning. $\delta =(\varepsilon ,\ \eta )$ $\varepsilon$ $\eta$

For N=64 og N=128 bit foreslås 3 typer angreb, og for N=256 - to. Kompleksiteten af de tilsvarende angreb:

Blok længde, bit	Nøglenængde, bit	$\delta$
64	128	$(2^{58},\ 2^{124}),\ (2^{60},\ 2^{78}),\ (2^{62},\ 2^{55})$
	192	$(2^{58},\ 2^{157}),\ (2^{60},\ 2^{96}),\ (2^{62},\ 2^{58})$
	256	$(2^{58},\ 2^{125}),\ (2^{60},\ 2^{78}),\ (2^{62},\ 2^{53})$
128	128	$(2^{122},\ 2^{95}),\ (2^{124},\ 2^{57}),\ (2^{126},\ 2^{52})$
	192	$(2^{122},\ 2^{142}),\ (2^{124},\ 2^{75}),\ (2^{126},\ 2^{58})$
	256	$(2^{122},\ 2^{168}),\ (2^{124},\ 2^{81}),\ (2^{126},\ 2^{63})$
256	128	$(2^{252},\ 2^{122}),\ (2^{254},\ 2^{119})$
	192	$(2^{252},\ 2^{181}),\ (2^{254},\ 2^{177})$
	256	$(2^{252},\ 2^{240}),\ (2^{254},\ 2^{219})$

I nogle tilfælde er versionen med 192-bit nøglen væsentligt mere sikker end versionen med den længere nøgle. Du kan også bemærke, at der er tilfælde, hvor kompleksiteten af angrebene af chifferen med den mindste nøglelængde og den største er næsten den samme. Derudover påvirker en forøgelse af nøglelængden ikke kompleksiteten af angrebet så meget, som vi ønsker.

Der er således angreb på NUSH-chifferet, der er mere effektive end brute force. Derfor er der en mulighed for, at disse angreb forbedres, eller at computerteknologien når et niveau, der er tilstrækkeligt til at bryde chifferen inden for rimelig tid.

Krypteringsalgoritme

Som et eksempel kan du overveje det andet angreb på en chiffer med en bloklængde på N=64 bit. Krypteringsanalyse er baseret på konstruktionen af afhængigheder mellem bits af nøglen, originalen og chifferteksten, gyldige med en sandsynlighed forskellig fra 1/2. Disse relationer er bygget på basis af en ligning, der er gyldig med en sandsynlighed på 3/4

$a_{i}[0]\oplus b_{i}[0]\oplus d_{i}[0]=a_{i-1}[0]\oplus b_{i-1}[0]\ oplus d_{i-1}[0]\oplus \theta$ , $\theta ={\begin{cases}1,&{\mbox{if }}\#=OR\\0,&{\mbox{if }}\#=AND\end{cases}}$

Denne ligning kan kontrolleres ved hjælp af beskrivelsen af algoritmen, og under hensyntagen til, at for den sidste (laveste) bit, er operationerne "+" og sammenfaldende. Faktisk har vi forholdet . Tilføjer vi forholdet til begge dele af ligningen, får vi det påkrævede. $\plus$ $d_{i}[0]=a_{i-1}[0]\oplus b_{i}[0]\oplus d_{i-1}\oplus \theta \ \Leftrightarrow \ b_{i}[ 0]\oplus d_{i}[0]=a_{i-1}[0]\oplus d_{i-1}\oplus \theta$ $a_{i}[0]=b_{i-1}[0]$

Yderligere, givet specifikke værdier , kan det vises, at det ikke afhænger af alle bits af nøglen og klarteksten, nemlig: $S_{i}$ $a_{2}[0]\oplus b_{2}[0]\oplus d_{2}[0]$

$a_{2}[0]\oplus b_{2}[0]\oplus d_{2}[0]\ =\ f_{1}(P_{0}[0-7],P_{1} [0-11],P_{2}[0-11],P_{3}[0],KS_{0}[0],KS_{1}[0-11],KS_{2}[0-11 ],KS_{3}[0-7],KR_{0}[0-11],KR_{1}[0-7])$

I betragtning af de første 4 runder af dekryptering, kan det fastslås, at . $a_{31}[0]\oplus b_{31}[0]\oplus d_{31}[0]\ =\ f_{2}(M_{0}[0-9],M_{1} [0-11],M_{2}[0-9,12],M_{3}[0,1],KF_{0}[0,1],KF_{1}[0-9,12], KF_{2}[0-11],KF_{3}[0-9],KR_{32}[0],KR_{33}[0],KR_{34}[0],KR_{35}[0 -9])$

Brug af Piling-up-lemmaet, med sandsynlighed . Vi fik forbindelsen mellem de centrale bits og de almindelige tekster og chiffertekster. $a_{2}[0]\oplus b_{2}[0]\oplus d_{2}[0]=a_{31}[0]\oplus b_{31}[0]\oplus d_{31 [0]$ $0,5+2^{-30}$ $m_{0}$

Fra nøgleskemaet kan det fås, at hvis nøglelængden er 128 eller 256 bit, så , hvis nøglen består af 192 bit, så . Ud fra disse data estimerer vi tidskompleksiteten af angrebet givet af følgende algoritme: $m_{0}=78$ $m_{0}=96$

for hver "nøgle" tæller vi antallet af åbne tekster, der opfylder det fundne forhold; $K'^{i}\in [1...2^{m_{0}}]$
find det maksimale af dem;
vi finder de resterende bits af nøglen: enten på lignende måde, ved at finde forhold eller ved opregning.

Kompleksiteten i forhold til mængden af lagret information er estimeret til . Det er, hvor mange åben-chiffertekst-par en kryptoanalytiker skal have. Samtidig er teksterne på ingen måde vilkårlige. Det kan ses af ovenstående relationer, at de ikke afhænger af alle bits af input- og outputblokkene. Følgelig skal der blandt prøven af klartekst- og chiffertekstblokke være blokke med forskellige tilsvarende bits. Driften af algoritmen med et mindre antal kendte tekster er mulig, men så er det mindre sandsynligt, at det "maksimale" antal fundet i andet trin faktisk svarer til den reelle nøgle i lyset af den ikke-overskridelse af roden af spredningen af antallet af begivenheder "ligningen er opfyldt" over måtten. forventning om forskellen i antallet af denne begivenhed og dens modsætning (du kan overveje Bernoulli-ordningen, hvor sandsynligheden for "succes" er lig med sandsynligheden for at opfylde forholdet). $2^{60}$ $f_{1},\ f_{2}$

Andre angreb, der foreslås i samme artikel, adskiller sig i analysen på det sidste trin af forholdet for andre runder og har ingen uafhængig interesse.

Andre NUSH-baserede algoritmer

Andre algoritmer kan bygges på basis af NUSH. I særdeleshed:

Hash-funktion

Inden hashing starter, forlænges teksten:

Tilføj 1 bit til tekst
Tilføj så mange nuller for at lave tekst med en længde, der er et multiplum af N (disse to trin kan udelades, hvis den oprindelige tekstlængde allerede er et multiplum af N)
Tildel en N-bit repræsentation af den indledende LEN-længde (i bits) af teksten
Tildel resultatet af en bitvis XOR mellem alle N-bit blokke af teksten opnået i det foregående trin

Funktionen bruger følgende variable:

$TEXT=[TEXT_{0}...TEXT_{l-1}]$ — udvidet tekst, præsenteret som blokke med længde N. $l$
$H=[H_{0}...H_{3}]$ , -registre af længde N, bestående af 4 n-bit ord $V=[V_{0}...V_{3}]$
$T=[T_{0}...T_{15}]$ b - registre med længden 4N, bestående af 15 n-bit ord / $M=[M_{0}...M_{15}]$

Startværdier: , , hvor er konstanter, der tilføjes til KR-nøglen under kryptering, KS=KF=KR=0 $T=[C_{0}...C_{15}]$ $M=[C_{16}...C_{31}]$ $C_{i}$

For i = 0 til l-1

{

For j=0 til L/2-1 er //L antallet af runder for den tilsvarende type NUSH {

C_{2j}=T_{jmod16}

{\displaystyle C_{2*j+1}=M_{jmod16))

}

V=TEXT_{i}

H = NUSH(V) //Krypteringsoperation

[H_{0}...H_{3}]+=[V_{0}...V_{3}]

For j=15 til 4

T_{j}=T_{j-4}

[T_{0}...T_{3}]=[H_{0}...H_{3}]

For j=15 til 4

{\displaystyle M_{j}=M_{j-4))

[M_{0}...M_{3}]=[V_{0}...V_{3}]

}

For i= 0 til 3

{

For j=0 til L/2-1

C_{2*j}=T_{jmod16}

H = NUSH( )

M_{i}

For j=15 til 4

T_{j}=T_{j-4}

[T_{0}...T_{3}]=[H_{0}...H_{3}]

}

Hashværdi af længde t*n (t<16) bits — første t n-bit ord i register T

Beskedgodkendelseskode

Baseret på hash-funktionen kan en meddelelsesgodkendelsesprocedure bygges. Den adskiller sig kun fra den tidligere algoritme ved brug af en nøgle, der ikke er nul .

Synkron stream cipher "NUSH Stream"

Lad SYNC være en kendt binær vektor med længde LENGTH. Der er to versioner af denne chiffer.

Mulighed 1

Lad N = LÆNGDE være længden af den blok, der bruges i NUSH-kryptering (LÆNGDE = 64, 128, 256) Lad være en vektor af COUNT N-bit ord, der vil blive tilføjet til almindelig tekst og chiffertekst til henholdsvis kryptering og dekryptering. $GAMMA=[GAMMA_{0}...GAMMA_{COUNT}]$

$SYNC=SYNC\oplus NUSH(SYNC)$

For i =0 til COUNT −1

{

GAMMA_{i}=NUSH(SYNC)

SYNC=(SYNC+65257)mod

2^N

}

Mulighed 2

Her er N=LÆNGDE / 2, hvor LÆNGDE = henholdsvis 128, 256, 512. Lad være en vektor med længden N, SYNC=[SYNC_0SYNC_1] er en vektor med længden 2N T er et midlertidigt register med længden N=4n, , , , er de tilsvarende konstanter for NUSH-algoritmen. $T=[T_{0}T_{1}T_{2}T_{3}]$ $C_{{n}}$ $C_{{n+1}}$ $C_{n+2}$ $C_{n+3}$

Udførte beregninger:

SYNC[0] = SYNC[0] ^ NUSH(SYNC[0])

SYNC[1] = SYNC[1] ^ NUSH(SYNC[1]) T=SYNC[1]

For i =0 til COUNT −1

{

[C_{n}C_{n+1}C_{n+2}C_{n+3}]=T

GAMMA_{i}=NUSH(SYNC_{0})

{\displaystyle SYNC_{0}=(SYNC_{0}+65257)mod\ 2^{N))

T = (T + 127)mod

2^N

}

Asymmetrisk kryptering

Valg af muligheder

En specifik gruppe G introduceres med en operation defineret af forfatterne af algoritmen baseret på Montgomery multiplikation.

Multiplikation Montgomery . Vi vælger et primtal P med længden n bit, tallet For to heltal A og B vil Montgomery-produktet være tallet: , hvor . At dividere med betyder at ignorere de nederste N bits af tallet. Gruppedrift: $N\geq n$ ${\displaystyle A\otimes B={\frac {AB+P(ABM\ mod\ 2^{N})}{2^{N))))$ $M=-P^{-1}\ mod\ 2^{N}$ $2^N$ $A\diamondsuit B={\begin{cases}A\otimes B&A\otimes B<P\\A\otimes BP&else\end{cases))$

$\ nogle gange$ beregnet med N=n. A og B anses for at være lige store, hvis de adskiller sig enten med P eller med 0. Der opnås en abelsk multiplikativ gruppe G. En isomorfi kan konstrueres mellem G og det reducerede system af rester modulo P: $\phi :G\ni m\rightarrow m\times 2^{N}\ mod\ P\in F_{P}^{*}$

Gruppen er konstrueret ved hjælp af et primtal P, således at det også er primtal. ${P-1} \over 2$

Algoritmens kryptografiske styrke er sikret af kompleksiteten af det diskrete logaritmeproblem. Kompleksiteten af hacking anslås til . I denne gruppe er generatoren a valgt. Privat nøgle: et tilfældigt heltal x ensartet fordelt på segmentet [0, P-2]. Offentlig nøgle: et element i gruppen G . $O(e^{{\frac {1}{3}}\time logP\times log^{2}P)})$ $b=a^{x}$

Kryptering

Tilfældig $r\in [1,P-1]$
Beregnet $c=a^{x}\in G$
$d=|b^{r}|$ , hvor |x|=x hvis x<P og |x|=xP ellers
$e=NUSH_{d}(M)$ , M er den oprindelige besked

Output: c||e

Dekryptering

$d=|b^{r}|$
$M=NUSH_{d}^{-1}(e)$

Elektronisk digital signatur

Denne algoritme er baseret på den tidligere beskrevne hash-funktion. Lad Q være et primtal af længde 2m bit, som er en divisor af tallet P-1. Under operationen vil vi forstå den operation, der allerede er introduceret tidligere , hvor Q bruges som et primtal. $A\circ B$ $Nogle gange B$

Offentlig nøgle

numrene P og Q
g er generatoren af en undergruppe af orden Q $H\subset G$
$b=g^{x\circ 1}$ , hvor x er den private nøgle.

Privat nøgle

Ethvert nummer . Ideelt valgt med en ensartet fordeling. $x\in [1,Q-1]$

Underskriver

Til en tilfældig beregning $r\in [1,Q-1]$ $c=|g^{r}|$
$d=Hash_{m}(BESKED||c)$ - en streng med længde m bit (om nødvendigt kasserer vi de nederste bits af hashværdien) (husk på, at m er halvdelen af længden af tallet Q). Det kan ske ved et tilfælde, at d=0. I dette tilfælde skal du genvælge en tilfældig r og udføre alle beregningerne.
$e=r-(x\circ d)\ mod\ Q$
signaturen inkluderer et par m bit d og e.

Signaturbekræftelse

Underskriften anses for korrekt, hvis jeg giver bevis for skemaets rigtighed. Det er klart, at algoritmens rigtighed svarer til rigtigheden af ligheden . $d=Hash_{m}(Besked||\ |g^{e}\diamondsuit b^{d}|)$ $c=|g^{e}\diamondsuit b^{d}|$

Den resulterende lighed kan omskrives som potenser af generatoren g af undergruppen H på følgende måde: . fra definitionen. Hvor . Operationen er lineær i det andet argument op til at tage lighed modulo Q. Faktisk, . Derfor ,. Hvorfra følger ligheden, der skal bevises, da rækkefølgen af elementet g er lig med Q. $|g^{rx\circ d}\diamondsuit (g^{x\circ 1})^{d}|=|g^{r}|$ $A=|A|\ mod\ P$ $g^{r-(x\circ d)+d(x\circ 1)}=g^{r}\ mod\ P$ $\cirk$ $A\otimes (b_{1}+...+b_{k})={\frac {A(b_{1}+...+b_{k})+Q((A(b_{ 1}+...+b_{n})M\ mod\ 2^{N})}{2^{N))}={\frac {Ab_{1}+Q((Ab_{1}M\ mod\ 2^{N})}{2^{N))}+...+{\frac {Ab_{k}+Q((Ab_{n}M\ mod\ 2^{N})}{ 2^{N}}}=A\cirkel b_{1}+...+A\cirkel b_{k}\ mod\ Q$ $d(x\circ 1)=x\circ d\ mod\ Q$

Godkendelsesskemaer

Godkendelsesprocessen ligner den digitale signaturordning. De offentlige og private nøgler vælges på nøjagtig samme måde. Den private nøgle opbevares af den person, der ønsker at bevise sin "identitet" (lad det være part A). Der er fire trin i godkendelsesprocessen:

A genererer et tilfældigt tal og sender til part B $r\in [1...Q-1]$ $c=Hash_{m}(|g^{r}|)$
B sender et tilfældigt tal . Jo højere t, jo højere er systemets pålidelighed. $k\in [1...2^{t}-1],\ t<2m$
A beregner og sender den til part B $d=rx\circ Hash_{m}(c||k)\ mod\ Q$
Godkendelse anses for bestået, hvis $Hash_{m}(|g^{d}\diamondsuit b^{Hash_{m}(c||k)}|)=c$

Noter

Links

NUSH på NESSIE-projektet Arkiveret 26. september 2007 på Wayback Machine
Lan Crypto hjemmeside Arkiveret 13. maj 2010 på Wayback Machine
Krypteringsanalyse (utilgængeligt link)
Forfatterens beskrivelse af algoritmen Arkiveret 12. august 2011 på Wayback Machine

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