CRYPTON

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 6. juni 2015; checks kræver 27 redigeringer .

CRYPTON

Skaber	Che Hong Lim (Future Systems, Inc.)
Oprettet	1998 _
offentliggjort	1998 - 1999
Nøglestørrelse	128, 192, 256 bit
Blokstørrelse	128 bit
Antal runder	12
Type	Substitution-permutation netværk

CRYPTON er en symmetrisk blokchiffer- algoritme (blokstørrelse 128 bit, nøgle op til 256 bit lang), udviklet af den sydkoreanske kryptolog Chae Hoon Lim fra det sydkoreanske firma Future Systems , som har opereret på netværkssikkerhedsmarkedet siden slutningen af 1980'erne og informationsbeskyttelse. Algoritmen blev udviklet i 1998 som en AES -chiffer . Som forfatteren indrømmede, er designet af algoritmen baseret på SQUARE- algoritmen .

Crypton-algoritmen indeholder ikke traditionelle Feistel-netværk til blokcifre . Grundlaget for denne chiffer er det såkaldte SP-netværk (repetitiv cyklisk funktion af substitutioner-permutationer, fokuseret på paralleliseret ikke-lineær behandling [1] af hele datablokken). Ud over høj hastighed letter fordelene ved sådanne algoritmer studiet af chifferens modstand mod metoderne til differentiel og lineær kryptoanalyse , som er de vigtigste værktøjer til at bryde blokcifre i dag.

En version af Crypton v0.5-algoritmen blev oprindeligt indsendt til AES-konkurrencen. Men som Che Hong Lim sagde, havde han ikke tid nok til at udvikle den fulde version. Og allerede i første fase af AES-konkurrencen, under analysen af algoritmer, blev Crypton v0.5-versionen erstattet af Crypton v1.0-versionen. Forskellen mellem den nye version og den originale var i at ændre erstatningstabellerne, i at ændre nøgleudvidelsesprocessen.

Strukturen af algoritmen. Nøglefunktioner

Ligesom andre AES-deltagere er Crypton designet til at kryptere 128-bit datablokke. Kryptering bruger krypteringsnøgler af flere faste størrelser - fra 0 til 256 bit med en multiplicitet på 8 bit.

Strukturen af Crypton-algoritmen - "Square"-strukturen - ligner på mange måder strukturen af Square-algoritmen , skabt i 1997. Kryptografiske transformationer for algoritmer med denne struktur kan udføres både på hele rækker og kolonner i arrayet og på dets individuelle bytes. (Det er værd at bemærke, at Square-algoritmen blev udviklet af forfatterne af den fremtidige vinder af AES-konkurrencen - forfatterne af Rijndael -algoritmen - Vincent Raymen og Joan Dimen .)

Kryptering

Crypton-algoritmen repræsenterer en 128-bit blok af krypterede data i form af et 4x4 byte-array, over hvilket der udføres flere runder af transformationer under krypteringsprocessen. I hver runde er det meningen, at følgende operationer skal udføres sekventielt:

Udskiftning af bord ; $\gamma$
Lineær transformation ; $\pi$
Byte permutation ; $\tau$
Betjening . $\sigma$

Tabellerstatning

\gamma

Crypton-algoritmen bruger 4 substitutionstabeller. Hver af dem erstatter en 8-bit inputværdi med et output af samme størrelse.

Alle tabeller er udledt fra hovedtabellen (se figur - beregning af afledte substitutionstabeller). $S_{0}...S_{3}$ $S$

Nedenfor er et eksempel på tabeller:

Tabel :

S_{0}

63	ec	59	aa	db	8e	66	c0	37	3c	fjorten	ff	13	44	a9	91
3b	78	8d	ef	c2	2a	f0	d7	61	9e	a5	f.Kr	48	femten	12	47
udg	42	1a	33	38	c8	17	90	a6	d5	5d	65	6a	fe	8f	a1
93	c2	2f	0c	68	58	df	f4	45	elleve	a0	a7	22	96	fb	7d
1d	b4	84	e0	bf	57	e9	0a	4e	83	cc	7a	71	39	c7	32
74	3d	de	halvtreds	85	06	6f	53	e8	annonce	82	19	e1	ba	36	cb
0e	28	f3	9b	4a	62	94	1f	bd	f6	67	41	d8	d1	2d	a4
86	b7	01	c5	b0	75	02	f9	2c	29	6e	d2	f5	8b	fc	5a
e4	7f	dd	07	55	b1	2b	89	72	atten	3a	4c	b6	e3	80	ce
49	jfr	6b	b9	f2	0d	dc	64	95	46	f7	ti	9a	tyve	a2	3f
d6	87	70	3e	21	fd	4d	7b	3c	ae	09	8a	04	b3	54	f8
tredive	00	56	d4	e7	25	bb	ac	98	73	ea	c9	9d	4f	7e	03
ab	92	a8	43	0f	fa	24	5c	1e	60	31	97	cd	c6	79	f5
5e	e5	34	76	1c	81	b2	af	0b	5d	d9	e2	27	6d	d0	88
c1	51	e6	9c	77	være	99	23	da	eb	52	2e	b5	08	05	6c
b8	1b	a3	69	8c	d3	40	26	f1	c4	9f	35	ee	7c	4b	16

Bord

{\displaystyle S_{1))

8d	b3	65	aa	6f	3a	99	03	dc	f0	halvtreds	ff	4c	elleve	a6	46
ec	e1	36	bf	0b	a8	c3	5f	85	7a	96	f2	21	54	48	1d
b7	09	68	cc	e0	23	5c	42	9a	57	75	95	a9	fb	3e	86
4e	2b	f.Kr	tredive	a1	61	7f	d3	femten	44	82	9e	88	5a	ef	f5
74	d2	12	83	fe	5d	a7	28	39	0e	33	e9	c5	e4	1f	c8
d1	f4	7b	41	16	atten	bd	4d	a3	b6	0a	64	87	ea	d8	2f
38	a0	jfr	6e	29	89	52	7c	f6	db	9d	05	63	47	b4	92
1a	de	04	17	c2	d5	08	e7	b0	a4	b9	4b	7d	2e	f3	69
93	fd	77	1c	55	c6	ac	26	c9	60	e8	31	da	8f	02	3b
25	3f	annonce	e6	cb	34	73	91	56	19	df	40	6a	80	8a	fc
5b	1e	c1	f8	84	f7	35	udg	0f	ba	24	2a	ti	ce	51	e3
c0	00	59	53	9f	94	ee	b2	62	cd	ab	27	76	3d	f9	0c
ae	4a	a2	0d	3c	eb	90	71	78	81	c4	5e	37	1b	e5	d7
79	97	d0	d9	70	06	ca	være	2c	6d	67	8b	9c	b5	43	22
07	45	9b	72	dd	fa	66	8c	6b	af	49	b8	d6	tyve	fjorten	b1
e2	6c	8e	a5	32	4f	01	98	c7	13	7e	d4	bb	f1	2d	58

Bord

S_{2}

b1	72	76	bf	ac	ee	55	83	udg	aa	47	d8	33	95	60	c4
9b	39	1e	0c	0a	1d	ff	26	89	5b	22	f1	d4	40	c8	67
9d	a4	3c	e7	c6	b5	f7	dc	61	79	femten	86	78	6e	eb	32
b0	ca	4f	23	d2	fb	5e	08	24	4d	8a	ti	09	51	a3	9f
f6	6b	21	c3	0d	38	99	1f	1c	90	64	fe	8b	a6	48	bd
53	e1	ea	57	ae	84	b2	45	35	02	7f	d9	c7	2a	d0	7c
c9	atten	65	00	97	2b	06	6a	34	f3	2c	92	ef	dd	7a	56
a2	c4	88	b9	halvtreds	75	d3	e4	elleve	ce	4b	a7	fd	3f	være	81
8e	d5	5a	49	42	54	70	a1	df	87	ab	7d	f4	12	05	2e
27	0f	c1	tredive	66	98	3d	cb	b8	e6	9c	63	e3	f.Kr	19	fa
3a	2f	9e	f2	6f	1a	28	3b	c2	0e	03	c0	b7	59	a9	d7
74	85	d6	annonce	41	ec	8c	71	f0	93	5d	b6	1b	68	e5	44
07	e0	fjorten	8a	f9	73	cd	4e	25	bb	31	5f	4a	cc	8f	91
de	6d	7b	f5	b3	29	a0	17	6c	da	e8	04	96	82	52	36
43	5c	db	8d	80	d1	e2	b4	58	46	ba	e9	01	tyve	fc	13
16	f8	94	62	37	jfr	69	9a	af	77	c5	3e	7e	a5	2d	0b

Tabel :

S_{{3}}

b1	f6	8e	07	72	6b	d5	e0	76	21	5a	fjorten	bf	c3	49	a8
ac	0d	42	f9	ee	38	54	73	55	99	70	cd	83	1f	a1	4e
udg	1c	df	25	aa	90	87	bb	47	64	ab	31	d8	fe	7d	5f
33	8b	f4	4a	95	a6	12	cc	60	48	05	8f	c4	bd	2e	91
9b	53	27	de	39	e1	0f	6d	1e	ea	c1	7b	0c	57	tredive	f5
0a	ae	66	b3	1d	84	98	29	ff	b2	3d	a0	26	45	cb	17
89	35	b8	6c	5b	02	e6	da	22	7f	9c	e8	f1	d9	63	04
d4	c7	e3	96	40	2a	f.Kr	82	c8	d0	19	52	67	7c	fa	36
9d	c9	3a	43	a4	atten	2f	5c	3c	65	9e	db	e7	00	f2	8d
c6	97	6f	80	b5	2b	1a	d1	f7	06	28	e2	dc	6a	3b	b4
61	34	c2	58	79	f3	0e	46	femten	2c	03	ba	86	92	c0	e9
78	ef	b7	01	6e	dd	59	tyve	eb	7a	a9	fc	32	56	d7	13
b0	a2	74	16	ca	4c	85	f8	4f	88	d6	94	23	b9	annonce	62
d2	halvtreds	41	37	fb	75	ec	jfr	5e	d3	8c	69	08	e4	71	9a
24	elleve	f0	af	4d	ce	93	77	8a	4b	5d	c5	ti	a7	b6	3e
09	fd	1b	7e	51	3f	68	a5	a3	være	e5	2d	9f	81	44	0b

Operationen bruges i lige runder og i ulige runder . Disse operationer og substitutionstabeller har en række egenskaber, der er vigtige, især for at forene krypterings- og dekrypteringsoperationer . Egenskaber for tabeller og operationer: ${\displaystyle \gamma _{e))$ $\gamma _{o}$

\gamma _{e}(\gamma _{o}(A))=\gamma _{o}(\gamma _{e}(A))=A;

S^{-1}=S;

S_{2}=S_{0}^{-1};

S_{3}=S_{1}^{-1};

hvor er den aktuelle værdi af den krypterede datablok. Operationerne og kan defineres som følger: $EN$ ${\displaystyle \gamma _{e))$ $\gamma _{o}$

\gamma _{e}:b_{ij}=S_{(j+2+imod4)}(a_{ij});

\gamma _{o}:b_{ij}=S_{(j+imod4)}(a_{ij}).

hvor:

$a_{{ij}}$ - den aktuelle værdi af en bestemt databyte;
$b_{{ij}}$ - værdien af databyten efter operationen;

Lineær transformation

\pi

Der er 4 specielle konstanter brugt her , hvis hexadecimale værdier er angivet nedenfor:

m_{0}=FC;

m_{1}=F3;

m_{2}=CF;

m_{3}=3F;

Disse konstanter kombineres til escape-sekvenser , som er angivet nedenfor:

M_{0}=m_{3}\bullet m_{2}\bullet m_{1}\bullet m_{0};

M_{1}=m_{0}\bullet m_{3}\bullet m_{2}\bullet m_{1};

M_{2}=m_{1}\bullet m_{0}\bullet m_{3}\bullet m_{2};

M_{3}=m_{2}\bullet m_{1}\bullet m_{0}\bullet m_{3};

hvor er sammenkædningsoperationen . $\kugle$

Selve operationen er en smule permutation. I ulige runder bruges operationen : $\pi$ $\pi _{o}$

B[0]=(A[3]\&M_{3})\oplus (A[2]\&M_{2})\oplus (A[1]\&M_{1})\oplus (A[ 0]\&M_{0});

B[1]=(A[3]\&M_{0})\oplus (A[2]\&M_{3})\oplus (A[1]\&M_{2})\oplus (A[ 0]\&M_{1});

B[2]=(A[3]\&M_{1})\oplus (A[2]\&M_{0})\oplus (A[1]\&M_{3})\oplus (A[ 0]\&M_{2});

B[3]=(A[3]\&M_{2})\oplus (A[2]\&M_{1})\oplus (A[1]\&M_{0})\oplus (A[ 0]\&M_{3});

hvor:

$\&$ - logisk bitvis operation "og";
$A[i]$ og — værdien af den i-te linje af de behandlede data henholdsvis før og efter operationen. $B[i]$

I lige runder bruges operationen : $\pi _{e}$

B[0]=(A[3]\&M_{1})\oplus (A[2]\&M_{0})\oplus (A[1]\&M_{3})\oplus (A[ 0]\&M_{2});

B[1]=(A[3]\&M_{2})\oplus (A[2]\&M_{1})\oplus (A[1]\&M_{0})\oplus (A[ 0]\&M_{3});

B[2]=(A[3]\&M_{3})\oplus (A[2]\&M_{2})\oplus (A[1]\&M_{1})\oplus (A[ 0]\&M_{0});

B[3]=(A[3]\&M_{0})\oplus (A[2]\&M_{3})\oplus (A[1]\&M_{2})\oplus (A[ 0]\&M_{1});

Faktisk sikrer denne operation, at hver resulterende byte i hver kolonne har to bits af hver kildebyte i den samme kolonne.

Byte-permutation

\tau

Denne permutation transformerer en række data til en kolonne på den enkleste måde:

{\displaystyle \tau :b_{ij}=a_{ji))

Operation

\sigma

Denne operation er en bitvis tilføjelse af hele dataarrayet med den runde nøgle:

{\displaystyle \sigma :B=A\oplus K_{r))

hvor: er den nye værdi af den krypterede datablok; - nøglen til den aktuelle runde . $B$ ${\displaystyle K_{r))$ $r$

Bemærk, at det er 12 runder af kryptering, der anbefales af forfatteren af algoritmen, Che Hong Lima, men et strengt antal runder er ikke blevet etableret. Ud over 12 runder med kryptering udføres der før den første runde af algoritmen en foreløbig operation , og efter 12 runder udføres en outputtransformation , bestående af sekventielt udførte operationer , og . $\sigma$ $\phi _{e}$ $\tau$ $\pi _{e}$ $\tau$

Dekryptering

Dekryptering udføres ved at anvende omvendte operationer i omvendt rækkefølge. Alle operationer, bortset fra og er omvendt til sig selv, og er i sig selv relateret af følgende relationer: ${\displaystyle \gamma _{e))$ $\gamma _{o}$ ${\displaystyle \gamma _{e))$ $\gamma _{o}$

\gamma _{e}^{-1}=\gamma _{o};

\gamma _{o}^{-1}=\gamma _{e},

derfor, når dechiffrering , - bruges i lige runder, og - i ulige. $\gamma _{o}$ ${\displaystyle \gamma _{e))$

Det er værd at bemærke endnu en funktion: hver fase kan udføres parallelt, hvilket er vigtigt, når det implementeres på moderne multi-core og multi-threaded systemer . Algoritmen har en SP-netværksstruktur, ligesom Rijndael (som er vinderen af AES-konkurrencen) Også et træk ved chifferen er, at den samme procedure kan bruges til at kryptere og dekryptere, men med forskellige undernøgler. Algoritmen er effektiv både i software- og hardwareimplementering. Chifferen er hurtig nok - ved AES-konkurrencen, ved hjælp af Borland C-kompileren, viste den de bedste resultater blandt alle deltagere.

Nøgleudvidelsesprocedure

Crypton-algoritmen kræver en 128-bit nøgle for hver runde, samt en 128-bit nøgle til pre-operation σ. Nøgleudvidelse sker i to faser:

i det første trin genereres otte udvidede nøgler;
på andet trin beregnes de runde nøgler ud fra de udvidede taster.

Udvidet nøglegenerering

De udvidede nøgler genereres som følger:

Hvis krypteringsnøglen er mindre end 256 bit, udfyldes den med bitnuller, indtil den når den originale 32-byte nøgle : $K$

{\displaystyle K=k_{31}\bullet ...\bullet k_{1}\bullet k_{0))

Nøglen K er parset i sekvenser og , hvoraf den første kun indeholder lige bytes af nøglen, den anden indeholder kun ulige bytes: $U$ $V$

U=U_{3}\bullet U_{2}\bullet U_{1}\bullet U_{0};

V=V_{3}\bullet V_{2}\bullet V_{1}\bullet V_{0};

U=k_{8i+6}\bullet k_{8i+4}\bullet k_{8i+2}\bullet k_{8i};

V=k_{8i+7}\bullet k_{8i+5}\bullet k_{8i+3}\bullet k_{8i+1};

Over og -sekvenserne udføres en runde kryptering af Crypton-algoritmen ved hjælp af en rundnøgle bestående af nul bit. Følgelig udføres ulige runde transformationer for og lige runde transformationer for. De resulterende sekvenser er betegnet som og . $U$ $V$ $U$ $V$ $du'$ $V'$
8 udvidede nøgler beregnes:

Ke_{i}=U'_{i}\oplus T_{1};

Ke_{i+4}=V'_{i}\oplus T_{0};

for hvor og er sekvenser defineret af følgende formler: $i=0,1,2,3,$ $T_{{1}}$ $T_{{0}}$

T_{0}=U'_{0}\oplus U'_{1}\oplus U'_{2}\oplus U'_{3};

T_{1}=V'_{0}\oplus V'_{1}\oplus V'_{2}\oplus V'_{3}.

Beregning af runde nøgler

For at beregne ud fra udvidede taster - runde taster bruges følgende konstanter:

C_{0}=A54FF53A;

C_{i}=C_{i-1}+3C6EF372mod2^{32};

Mc_{0}=ACACACAC;

Bemærk, at de pseudo-tilfældige konstanter A54FF53A og 3C6EF372 er opnået fra brøkdelene af tal og hhv. ${\sqrt {7}}$ ${\sqrt {5}}$

Først beregnes nøglerne til den indledende operation σ og den første runde:

K_{0}[i]=Ke_{i}\oplus C_{0}\oplus Mc_{i};

K_{1}[i]=Ke_{i+4}\oplus C_{1}\oplus Mc_{i};

hvor er den i-te række af den runde nøgle . Som med krypterede data leveres nøglen i form af en tabel. $K_{r}[i]$ $r$

Konstanter beregnes ved bitvis at rotere hver byte af konstanten 1 bit til venstre. $Mc_{i}[i]$ $Mc_{i-1}$

For den anden og hver efterfølgende lige runde udregnes nøglen som følger:

De første fire udvidede nøgler er ændret:

\{Ke_{3},Ke_{2},Ke_{1},Ke_{0}\}\venstrepil \{Ke_{0}<<<6,Ke_{3}<<<6,Ke_{ 2}<<16,Ke_{1}<<24\};

hvor <<< angiver operationen af bitvise rotation af hver byte (separat) af den udvidede nøgle med det specificerede antal bits til venstre, og << er den bitvise rotation af hele nøglen med det specificerede antal bits til venstre .

Beregning af den runde nøgle ved hjælp af modificerede udvidede taster:

K_{r}[i]=Ke_{i}\oplus C_{r}\oplus Mc_{i};

På samme måde sker beregningen af nøgler for ulige runder:

\{Ke_{7},Ke_{6},Ke_{5},Ke_{4}\}\leftarrow \{Ke_{6}<<16,Ke_{5}<<8,Ke_{4} <<<2,Ke_{7}<<<2\};

K_{r}[i]=Ke_{i+4}\oplus C_{r}\oplus Mc_{i};

Nøgleudvidelsesproceduren giver dig mulighed for at generere rundnøgler på farten, det vil sige i krypteringsprocessen efter behov. Dette er en klar fordel ved algoritmen, i det mindste fordi der ikke kræves nogen hukommelse til at gemme runde nøgler. Til dekryptering er det også muligt at udføre en direkte nøgleudvidelsesprocedure og bruge de opnåede rundnøgler i omvendt rækkefølge.

Sikkerhed

Ulemper ved Crypton-algoritmen

Da de analyserede den originale version af algoritmen, Crypton v0.5, opdagede to eksperter uafhængigt af hinanden en klasse af svage nøgler: der var 2 i kraft af 32 256-bit nøgler. Også et angreb på den seks-runde version af Crypton-algoritmen, svarende til angrebet på Square-algoritmen, blev opdaget. Dette var en af grundene til fremkomsten af en ny version af algoritmen - Crypton v1.0.

Fordele ved Crypton-algoritmen

Men ifølge eksperter fra NIST Institute er ovenstående ulemper ikke grove. Derudover havde algoritmen ganske nok fordele:

algoritmen er effektiv på software- og hardwareniveauer på grund af den høje grad af parallelitet og brugen af meget simple ANDS / XORS logiske operationer;
algoritmen er ikke genstand for angreb på eksekveringstid og strømforbrug;
god modstand mod eksisterende angreb;
muligheden for at parallelisere operationer i krypteringsprocessen;
hurtig nøgleudvidelse, hurtig nøglegenerering: nøglelistekryptering er meget hurtigere end enkeltblokkryptering, så det er meget effektivt i applikationer, der kræver hyppige nøgleændringer (f.eks. hash-tilstand).
tilstrækkelig høj hastighed på alle målplatforme;
små krav til RAM og muligheden for at udvide nøglen i farten gør det muligt at bruge Crypton-algoritmen i smart cards med minimale ressourcer;
Algoritmen understøtter yderligere nøglestørrelser ud over dem, der er indstillet af konkurrenterne (128, 192, 256 bit).

Udvikleren erklærede garanteret modstand mod lineær og differentiel kryptoanalyse og generelt mod alle angreb, der eksisterede på udviklingstidspunktet. Det nydesignede nøgleskema og de nye S-Box-tabeller eliminerede alle de identificerede mangler og sårbarheder .

Integreret angreb på Crypton-chifferet (4-runde)

Sikkerhedsanalyse af den bloksymmetriske cipher (BSC) Crypton viser, at den 12-runde selverstattende cipher (med samme processer til kodning og dekryptering) med en bloklængde på 128 bit og en nøglelængde på op til 128 bit har god modstand til eksisterende angreb. Et integreret angreb på en 4-runders Crypton BSS er meget mere effektiv end en brute-force-søgning over hele nøglerummet.

Kort beskrivelse af chifferen

Crypton er en blokcifre. Nøglængden og bloklængden er 128 bit. De fire transformationer arbejder med et mellemresultat kaldet Staten. Tilstanden kan repræsenteres som en rektangulær matrix på 16 bytes:

(A_{i,j})

hvor

A\in \{0,...,3\}

Lad os betegne en 4-byte kolonne som $A_{j}=(A_{0j},A_{1j},A_{2j},A_{3j})$

Lad os også forestille os krypteringsnøglen:

(K_{i,j})

hvor og .

{\displaystyle K\in \{0,...,3\))

K_{j}=(K_{0j},K_{1j},K_{2j},K_{3j})

Chifferen definerer et Galois-felt, hvis elementer er bytes. Bytes behandles som polynomier over $GF(2^{8})$ $Z_{2}$

b\leftrightarrow b_{7}x^{7}+b_{6}x^{6}+b_{5}x^{5}+b_{4}x^{4}+b_{3} x^{3}+b_{2}x^{2}+b_{1}x^{1}+b_{0}

Tilføjelsesoperation - når der tilføjes bytes, tilføjes de tilsvarende polynomier over . $\plus$ $Z_{2}$

Multiplikationsoperation - under multiplikation multipliceres de tilsvarende polynomier, og det resulterende polynomium tages modulo fra et simpelt polynomium $Z_{2}$

m(x)=x^{8}+x^{4}+x^{3}+x^{1}+1

Under algoritmens drift udvides nøglen (nøgleskema, nøgleudvidelse). De første 4 kolonner (4 bytes hver) er den originale nøgle . Hvert efterfølgende -th sæt af 4 kolonner beregnes ud fra det forrige sæt og bruges til -th runde, angivet med . En runde består af fire forskellige elementære transformationer, der transformerer en tilstand til en tilstand : $(K_{i,j})$ $K^{0}$ $r$ $r$ $K^{r}=(K_{i,j}^{r})$ $A=(A_{i,j})$ $B=(B_{i,j})$

Byte substitution - BS (Byte Substitution): anvendelse af en permutation eller $S$ $B_{i,j}=S(A_{i,j})$
Rækkeskift - SR (Shift Rows): cyklisk skift af bytes i henhold til reglen: ${\displaystyle B_{i,j}=A_{i,(j+1)mod4))$
Kolonneblanding - MC (Mix Columns: hver tilstandskolonne modificeres ved en lineær transformation $\mu :(0,1)^{32}\højrepil (0,1)^{32}$

Med andre ord er dette ikke andet end at gange kolonnerne med matrixen til venstre: $B=\mu (A)=E={\begin{pmatrix}2&3&1&1\\1&2&3&1\\1&1&2&3\\3&1&1&2\end{pmatrix))$

Operationen er reversibel: $\mu$ $A_{j}=\mu ^{-1}(B_{j})$

Tilføjelse af en rund tast - KA (Key Addition): en rund tast tilføjes til den aktuelle tilstand.

Slutrunden indeholder ikke en MC-operation. Formler, der forbinder tilstande og : $A^{r}$ $A^{r-1}$

A^{r}=MC(SR(S(A^{r-1})))\oplus K^{r-1}

;

A^{r-1}=S^{-1}(SR^{-1}(MC^{-1}(A^{r}\oplus K^{r-1})))

; Algoritme til implementering af et integreret angreb

Det integrerede angreb er baseret på muligheden for fri udvælgelse af angriberen af et bestemt sæt klartekster til deres efterfølgende kryptering. Det er mere effektivt end udtømmende opregning over hele nøglerummet.

Vi introducerer definitioner.

$\lambda$ - et sæt af 256 inputblokke (State arrays), som hver har bytes (lad os kalde dem aktive), hvis værdier er forskellige for alle 256 blokke. Resten af bytes (passive) forbliver de samme for alle 256 blokke fra -sættet. Det vil sige for enhver, hvis byten med indeks (i, j) er aktiv og ellers . $\lambda$ $A,B\in \Lambda$ ${\displaystyle A_{ij}\neq B_{ij))$ $A_{ij}=B_{ij}$

{\displaystyle \Lambda ^{r))

- ck aktive bytes.

\lambda

{\displaystyle P_{r))

er mængden af tilstande i slutningen af runde r.

$\lambda$ -sæt. Efter elementære transformationer BS og KA vil -sæt-blokkene resultere i et andet -sæt med aktive bytes i samme positioner som det oprindelige. SR-konverteringen vil flytte disse bytes i overensstemmelse med de forskydninger, der er angivet i den. Efter transformationen vil et MC -sæt ikke nødvendigvis forblive et -sæt i det generelle tilfælde (resultatet af operationen opfylder muligvis ikke længere definitionen af et -sæt). Da hver byte i MC-resultatet er en lineær kombination (med reversible koefficienter) af de fire inputbytes i samme kolonne , vil en kolonne med en enkelt aktiv byte i inputtet resultere i en kolonne med alle fire aktive bytes i outputtet. $\lambda$ $\lambda$ $\lambda$ $\lambda$ $\lambda$ ${\displaystyle B_{ij))$ ${\displaystyle B_{ij}=2A_{ij}\oplus 3A_{i+1mod4j}\oplus A_{i+2mod4j}\oplus A_{i+3mod4j))$

Overvej -sæt kryptering. Kun én byte vil være aktiv i alle blokke. Værdien af denne byte er forskellig i alle 256 blokke, og resten af bytene er de samme. I første runde konverterer MC-transformationen en aktiv byte til en kolonne med 4 aktive bytes , dvs. I anden runde vil disse 4 bytes gå ind i 4 forskellige kolonner som følge af transformationen SR, er et -sæt. MC-transformationen af den næste, tredje runde vil transformere disse bytes til 4 kolonner, der indeholder de aktive bytes. Dette sæt er stadig et -sæt, indtil det kommer ind i tredje runde MC input. $\Lambda ^{1}$ $P_1$ $\Lambda ^{4}$ $P_2$ $\Lambda ^{16}$ $\lambda$

Hovedegenskaben for et sæt er den bitvise sum modulo 2 ( ) af alle bytes placeret på de samme steder i hele sættet er lig med nul (den bitvise sum af inaktive (med samme værdier) bytes er nul ved definition af " " operation, og aktive bytes, der løber gennem alle 256 værdier, også med bitvis summering vil de give nul) $\lambda$ $\plus$ $\plus$

Resultatet af MC-konverteringen i den tredje runde af bytes af inputdataarrayet til bytes af outputdataarrayet er den bitvise sum af alle blokke af outputsættet vil være lig med nul: $EN$ $B$

\oplus _{B=MC(A),A\in \Lambda ^{1}6}B_{ij}=\oplus _{A\in \Lambda ^{1}6}(2A_{ij} \oplus 3A_{i+1mod4j}\oplus A_{i+2mod4j}\oplus A_{i+3mod4j})=0

Således er der . Den samlede sum af inputdata er nul. Denne lighed krænkes af den efterfølgende BS-transformation. $P_{3}$ $\Lambda ^{16}$

Nøglen er unikt specificeret i R-repræsentationen: $K^{r}$

L^{r}=SR^{-1}(MC^{-1}(K^{r}))

K^{r}=MC(SR(L^{r}))

For at udføre angrebet kræves et sæt bestående af 256 stater. Sættet kan opnås ved at anvende 2 inverse transformationer SR og MC fra chifferinputtet . $Q_{4}$ ${\displaystyle Q_{r}=SR^{-1}(MC^{-1}(A)),A\in P_{r))$ $Q_{4}$ $P_{4}$

Skema for et grundlæggende integreret angreb på en 4-rund Crypton:

For alle $i,j\in {0,1,2,3}$

til $k\inGF(2^{8})$

hvis , $\oplus _{Z\in Q}S^{-1}(Z_{ij}\oplus k)\neq 0$

derefter $L_{ij}^{4}\neq k$

I dette skema inverteres 4. runde trin for trin for at få bytes , hvis samlede sum er 0. Når summen $P_{3}$ $L_{ij}^{4}=k$ $\oplus _{Z\in Q}S^{-1}(Z_{ij}\oplus k)=0$

Hvis den forventede værdi af nøglebyten var korrekt, vil den blive inkluderet i de mulige valg på plads . De fleste af de dårlige byteværdier vil blive luget ud. På grund af det faktum, at søgningen kan udføres separat (parallelt) for hver byte af nøglen, er hastigheden til at vælge hele værdien af den runde nøgle meget høj. Yderligere efter værdi kan du finde , og derefter og - den originale nøgle. $L^{4}$ $L^{4}$ $K^{4}$ $K^{0}$

AES-konkurrence

De første skridt mod at ændre krypteringsstandarder var oprettelsen af AES-konkurrencen. Det var en åben konkurrence afholdt af US Institute of Standards and Technology - NIST (National Institute of Standard and Technology). Vinderen af denne konkurrence skulle være den nye amerikanske krypteringsstandard. Enkeltpersoner, virksomheder både i USA og uden for landet kunne deltage i konkurrencen.

Primære krav:

128 bit - størrelsen af blokken af krypterede data.
Tre eller flere nøglestørrelser skal understøttes af algoritmen (128, 256, 192 - bits er obligatoriske nøglestørrelser til konkurrencen).

Men på trods af det lille antal krav til algoritmer var der mange ønsker:

Algoritmen skal være modstandsdygtig over for kryptoanalytiske angreb kendt på konkurrencetidspunktet;
strukturen af algoritmen skal være klar, enkel og begrundet;
der må ikke være svage og tilsvarende nøgler;
datakrypteringshastigheden bør være høj på alle potentielle hardwareplatforme fra 8 til 64 bit.
strukturen af algoritmen bør tillade paralleliseringsoperationer i multiprocessorsystemer og hardwareimplementeringer.
Algoritmen skal stille minimumskrav til operationel og ikke-flygtig hukommelse.
der bør ikke være begrænsninger for brugen af algoritmer.

Bemærk, at deltagerne i AES-konkurrencen fik lov til at foretage ændringer i algoritmerne under konkurrencen, hvis disse var mindre ændringer. For Crypton-algoritmen anså juryen ændringerne for at være væsentlige, da de vedrørte substitutionstabellen, nøgleudvidelsesproceduren, da de leverede en ny version. Som et resultat deltog versionen af Crypton v0.5 i konkurrencen.

Fraværet af åbenlyse ulemper og tilstedeværelsen af fordele i Crypton-algoritmen tillod det stadig ikke at nå finalen i AES-konkurrencen. Årsagen til dette var deltagelse i konkurrencen af to algoritmer: Rijndael og Twofish . Disse algoritmer havde ikke de svage nøgleproblemer i Crypton-algoritmen. Desuden var de hurtigere end Crypton på målplatformene. Det blev besluttet, at Crypton i fremtiden ville tabe til disse algoritmer under alle omstændigheder, så konkurrenceeksperterne lod ikke Crypton komme videre til finalen. (Rijndael er den fremtidige vinder af konkurrencen).

Versioner af Crypton-algoritmen

Konkurrencen involverede den primære version af algoritmen, som fik et indeks på 0,5 efter nogen tid. Efter nogen tid blev der foreslået flere udgaver, hvoraf den seneste var version 1.0 med et revideret nøgleskema og nye opslagstabeller.

Noter

↑ Bukharov O.E., Bogolyubov D.P. Parallelt selvlærende beslutningsstøttesystem baseret på genetiske algoritmer og neurale netværk (russisk) // Systemadministrator. - 2014. - Nr Udgave nr. 9 (142) . Arkiveret fra originalen den 28. januar 2021.

Litteratur

Chae Hoon Lim. CRYPTON: en ny 128-bit blokcifer-specifikation og analyse. - 1998. - doi : 10.1.1.52.5771 .
Krypteringsalgoritmer. Særligt register / forfatter: Sergey Petrovich Panasenko / Udgiver: "BHV-St. Petersburg", 2009

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