DES

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 22. marts 2015; kontroller kræver 72 redigeringer .

DES, Data Encryption Standard
Skaber	IBM
Oprettet	1977 _
offentliggjort	1977 _
Nøglestørrelse	56 bit + 8 test
Blokstørrelse	64 bit
Antal runder	16
Type	Feistel netværk
Mediefiler på Wikimedia Commons

DES ( English Data Encryption Standard ) er en algoritme til symmetrisk kryptering udviklet af IBM og godkendt af den amerikanske regering i 1977 som en officiel standard ( FIPS 46-3). Blokstørrelsen for DES er 64 bit . Algoritmen er baseret på et Feistel-netværk med 16 cyklusser ( runder ) og en nøgle på 56 bit . Algoritmen bruger en kombination af ikke-lineære (S-bokse) og lineære (E, IP, IP-1 permutationer) transformationer. Flere tilstande anbefales til DES:

ECB ( engelsk elektronisk kodebog ) - "elektronisk kodebog " -tilstand (simpel udskiftning) ;
CBC ( engelsk c ipher b lock chaining ) - blokkæde -tilstand;
CFB ( eng. c ipher feed - back ) - chiffertekstfeedback - tilstand ;
OFB ( eng. output f eed b ack ) - udgangsfeedback -tilstand;
Tællertilstand (CM) - tællertilstand.

En direkte udvikling af DES er i øjeblikket Triple DES (3DES) algoritmen. I 3DES udføres kryptering/dekryptering ved at køre DES-algoritmen tre gange.

Historie

I 1972 blev der gennemført en undersøgelse af den amerikanske regerings behov for computersikkerhed. Det amerikanske "National Bureau of Standards" (NBS) (nu kendt som NIST - "National Institute of Standards and Technology") identificerede behovet for en regeringsdækkende standard for kryptering af ikke-kritisk information.

NBS rådførte sig med NSA (US National Security Agency) og annoncerede den 15. maj 1973 den første konkurrence om oprettelse af en chiffer. Der blev formuleret strenge krav til den nye chiffer. IBM deltog i konkurrencen med en chiffer, den havde udviklet kaldet "Lucifer " . Ingen af deltagernes chiffer (inklusive "Lucifer") sikrede ikke opfyldelsen af alle krav. I løbet af 1973-1974 færdiggjorde IBM sin "Lucifer": den brugte Horst Feistel- algoritmen , der blev oprettet tidligere. Den 27. august 1974 begyndte den anden konkurrence. Denne gang blev chifferen "Lucifer" anset for acceptabel.

Den 17. marts 1975 blev den foreslåede DES-algoritme offentliggjort i det føderale register. I 1976 blev der afholdt to offentlige symposier for at diskutere DES. På symposierne blev ændringer foretaget af algoritmen af NSA stærkt kritiseret. NSA reducerede den oprindelige nøglelængde og S-bokse (substitutionsbokse), hvis designkriterier ikke blev oplyst. NSA var mistænkt for bevidst at svække algoritmen, så NSA nemt kunne se krypterede beskeder. Det amerikanske senat gennemgik NSA's handlinger og udgav en erklæring i 1978 , der sagde følgende:

under udviklingen af algoritmen overbeviste repræsentanter for NSA skaberne af DES om, at den reducerede nøglelængde er mere end nok til alle kommercielle applikationer;
NSA-repræsentanter bistod indirekte i udviklingen af S-permutationer;
den endelige version af algoritmen var efter verifikatorernes mening den bedste krypteringsalgoritme, desuden uden statistiske eller matematiske svagheder;
NSA-repræsentanter blandede sig aldrig i udviklingen af DES-algoritmen.

I 1990 udførte Eli Biham og Adi Shamir uafhængig forskning i differentiel krypteringsanalyse , den vigtigste metode til at bryde bloksymmetriske krypteringsalgoritmer . Disse undersøgelser fjernede nogle af mistankerne om den skjulte svaghed ved S-permutationer. S-bokse af DES-algoritmen viste sig at være meget mere modstandsdygtige over for angreb, end hvis de var tilfældigt udvalgt. Det betyder, at denne analyseteknik var kendt af NSA allerede i 1970'erne.

DES-algoritmen blev "hacket" på 39 dage ved hjælp af et enormt netværk af titusindvis af computere [1] .

Den offentlige organisation " EFF ", der beskæftiger sig med problemerne med informationssikkerhed og personligt privatliv på internettet , iværksatte en undersøgelse "DES Challenge II" for at identificere problemer med DES. Som en del af undersøgelsen byggede medarbejdere i RSA Laboratory en supercomputer til $ 250.000. I 1998 dekrypterede supercomputeren DES-kodede data ved hjælp af en 56-bit nøgle på mindre end tre dage. Supercomputeren fik navnet "EFF DES Cracker". Specielt til denne lejlighed organiserede videnskabsmænd en pressekonference og talte med bekymring over, at angribere sandsynligvis ikke vil gå glip af muligheden for at drage fordel af en sådan sårbarhed.

Nogle embedsmænd og eksperter har hævdet, at knække DES-koden kræver en multi-million dollar supercomputer. "Det er på tide, at regeringen anerkender usikkerheden ved DES og støtter skabelsen af en stærkere krypteringsstandard," sagde EFF-præsident Barry Steinhardt. Eksportrestriktioner pålagt af den amerikanske regering gælder for krypteringsteknologier med nøgler længere end 40 bit. Men som resultaterne af RSA Laboratory-eksperimentet viste, er der mulighed for at knække endnu mere kraftfuld kode. Problemet blev forværret af, at omkostningerne ved at bygge sådan en supercomputer støt faldt. "Om fire eller fem år vil disse computere være på hver skole," sagde John Gilmour, projektleder for DES Challenge og en af grundlæggerne af EFF.

DES er en blokcifre. For at forstå, hvordan DES fungerer, er det nødvendigt at overveje arbejdsprincippet for en blokchiffer , Feistel-netværket .

Blok chiffer

Indgangsdataene for blokchifferet er:

blokstørrelse n bits;
nøgle af størrelse k bits.

Outputtet (efter anvendelse af krypteringstransformationer) er en krypteret blok af størrelse n bit, og mindre forskelle i inputdataene fører som regel til en væsentlig ændring i resultatet.

Blokcifre implementeres ved gentagne gange at anvende visse grundlæggende transformationer til blokke af kildetekst .

Grundlæggende transformationer:

kompleks transformation på en lokal del af blokken;
simpel ombygning mellem blokdele.

Da transformationerne udføres blok for blok, er det nødvendigt at opdele kildedataene i blokke af den nødvendige størrelse. I dette tilfælde er formatet på kildedataene ligegyldigt (det være sig tekstdokumenter, billeder eller andre filer). Dataene skal fortolkes i binær form (som en sekvens af nuller og enere) og skal først derefter opdeles i blokke. Alt ovenstående kan implementeres både i software og i hardware.

Feistel netværkstransformationer

Dette er en transformation over vektorer ( blokke ), der repræsenterer venstre og højre halvdel af skifteregisteret. DES-algoritmen bruger fremadgående transformation af Feistel-netværket til kryptering (se fig. 1) og invers transformation af Feistel-netværket ved dekryptering (se fig. 2).

DES krypteringsskema

Krypteringsskemaet for DES-algoritmen er vist i fig.

Kildeteksten er en blok på 64 bit.

Krypteringsprocessen består af en indledende permutation, 16 krypteringscyklusser og en endelig permutation.

Indledende permutation

Den originale tekst (blok på 64 bit) konverteres ved hjælp af den indledende permutation, som bestemmes af tabel 1: $T$ $\mathrm{IP}$

Tabel 1. IP initial permutation

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

Ifølge tabellen er de første 3 bit af den resulterende blok efter den indledende permutation bit 58, 50, 42 i inputblokken , og dens sidste 3 bit er bit 23, 15, 7 i inputblokken. $\mathrm{IP}(T)$ $\mathrm{IP}$ $T$

Krypteringscyklusser

64-bit blok IP(T) opnået efter den indledende permutation deltager i 16 cyklusser af Feistel-transformationen.

- 16 cyklusser af Feistel -transformationen :

Opdel IP(T) i to dele , hvor er henholdsvis 32 høje bits og 32 lave bits af blok IP(T)= $L_0, R_0$ $L_0, R_0$ $T_{0}$ $L_0R_0$

Lad resultatet være (i-1) iteration, så bestemmes resultatet af den i-te iteration af: $T_{i-1} = L_{i-1}R_{i-1}$ $T_i = L_iR_i$

L_i = R_{i-1}

R_i = L_{i-1}\oplus f(R_{i-1},k_i)

Den venstre halvdel er lig med den højre halvdel af den forrige vektor . Og den højre halvdel er bitvis addition modulo 2. $L_i$ $L_{i-1}R_{i-1}$ $R_i$ $L_{i-1}$ $f(R_{i-1},k_i)$

I de 16 cyklusser af Feistel-transformationen spiller funktionen f rollen som en kryptering . Lad os overveje funktionen f i detaljer.

Grundlæggende krypteringsfunktion (Feistel-funktion)

Funktionens argumenter er en 32-bit vektor og en 48-bit nøgle , som er resultatet af transformation af den 56-bit originale chiffernøgle . For at beregne funktionen skal du successivt bruge $f$ $R_{i-1}$ $k_i$ $k$ $f$

udvidelsesfunktion , _ $\mathrm{E}$
addition modulo 2 med nøgle $k_i$
transformation , bestående af 8 transformationsblokke , $\mathrm{S}$ $\mathrm{S}$ $\mathrm{S}_1,\mathrm{S}_2,\mathrm{S}_3\ldots\ \mathrm{S}_8$
permutation . $\mathrm{P}$

Funktionen udvider en 32-bit vektor til en 48-bit vektor ved at duplikere nogle bits fra ; vektorens bitrækkefølge er angivet i tabel 2. $\mathrm{E}$ $R_{i-1}$ $\mathrm{E}(R_{i-1})$ $R_{i-1}$ $\mathrm{E}(R_{i-1})$

Tabel 2. Udvidelsesfunktion E

32	en	2	3	fire	5
fire	5	6	7	otte	9
otte	9	ti	elleve	12	13
12	13	fjorten	femten	16	17
16	17	atten	19	tyve	21
tyve	21	22	23	24	25
24	25	26	27	28	29
28	29	tredive	31	32	en

De første tre bit af vektoren er bit 32, 1, 2 af vektoren . Tabel 2 viser, at bit 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29, 32 er duplikeret. De sidste 3 bit af vektoren er bit 31, 32, 1 af vektoren . Blokken opnået efter permutationen tilføjes modulo 2 med tasterne og præsenteres derefter i form af otte på hinanden følgende blokke . $\mathrm{E}(R_{i-1})$ $R_{i-1}$ $E(R_{i-1})$ $R_{i-1}$ $\mathrm{E}(R_{i-1})$ $k_i$ $B_1,B_2,...B_8$

\mathrm{E}(R_{i-1})\oplus k_i= B_1B_2...B_8

Hver er en 6-bit blok. Yderligere transformeres hver af blokkene til en 4-bit blok ved hjælp af transformationer . Transformationerne er defineret i tabel 3. $B_j$ $B_j$ $B'_j$ $S_j$ $S_j$

Tabel 3. Transformationer , i=1…8

S_{i}

	0	en	2	3	fire	5	6	7	otte	9	ti	elleve	12	13	fjorten	femten

0	fjorten	fire	13	en	2	femten	elleve	otte	3	ti	6	12	5	9	0	7
en	0	femten	7	fire	fjorten	2	13	en	ti	6	12	elleve	9	5	3	otte	$S_{1}$
2	fire	en	fjorten	otte	13	6	2	elleve	femten	12	9	7	3	ti	5	0
3	femten	12	otte	2	fire	9	en	7	5	elleve	3	fjorten	ti	0	6	13

0	femten	en	otte	fjorten	6	elleve	3	fire	9	7	2	13	12	0	5	ti
en	3	13	fire	7	femten	2	otte	fjorten	12	0	en	ti	6	9	elleve	5	$S_{2}$
2	0	fjorten	7	elleve	ti	fire	13	en	5	otte	12	6	9	3	2	femten
3	13	otte	ti	en	3	femten	fire	2	elleve	6	7	12	0	5	fjorten	9

0	ti	0	9	fjorten	6	3	femten	5	en	13	12	7	elleve	fire	2	otte
en	13	7	0	9	3	fire	6	ti	2	otte	5	fjorten	12	elleve	femten	en	$S_{3}$
2	13	6	fire	9	otte	femten	3	0	elleve	en	2	12	5	ti	fjorten	7
3	en	ti	13	0	6	9	otte	7	fire	femten	fjorten	3	elleve	5	2	12

0	7	13	fjorten	3	0	6	9	ti	en	2	otte	5	elleve	12	fire	femten
en	13	otte	elleve	5	6	femten	0	3	fire	7	2	12	en	ti	fjorten	9	$S_4$
2	ti	6	9	0	12	elleve	7	13	femten	en	3	fjorten	5	2	otte	fire
3	3	femten	0	6	ti	en	13	otte	9	fire	5	elleve	12	7	2	fjorten

0	2	12	fire	en	7	ti	elleve	6	otte	5	3	femten	13	0	fjorten	9
en	fjorten	elleve	2	12	fire	7	13	en	5	0	femten	ti	3	9	otte	6	$S_5$
2	fire	2	en	elleve	ti	13	7	otte	femten	9	12	5	6	3	0	fjorten
3	elleve	otte	12	7	en	fjorten	2	13	6	femten	0	9	ti	fire	5	3

0	12	en	ti	femten	9	2	6	otte	0	13	3	fire	fjorten	7	5	elleve
en	ti	femten	fire	2	7	12	9	5	6	en	13	fjorten	0	elleve	3	otte	$S_6$
2	9	fjorten	femten	5	2	otte	12	3	7	0	fire	ti	en	13	elleve	6
3	fire	3	2	12	9	5	femten	ti	elleve	fjorten	en	7	6	0	otte	13

0	fire	elleve	2	fjorten	femten	0	otte	13	3	12	9	7	5	ti	6	en
en	13	0	elleve	7	fire	9	en	ti	fjorten	3	5	12	2	femten	otte	6	$S_7$
2	en	fire	elleve	13	12	3	7	fjorten	ti	femten	6	otte	0	5	9	2
3	6	elleve	13	otte	en	fire	ti	7	9	5	0	femten	fjorten	2	3	12

0	13	2	otte	fire	6	femten	elleve	en	ti	9	3	fjorten	5	0	12	7
en	en	femten	13	otte	ti	3	7	fire	12	5	6	elleve	0	fjorten	9	2	$S_8$
2	7	elleve	fire	en	9	12	fjorten	2	0	6	ti	13	femten	3	5	otte
3	2	en	fjorten	7	fire	ti	otte	13	femten	12	9	0	3	5	6	elleve

Antag det , og vi vil gerne finde . Det første og sidste ciffer er den binære repræsentation af tallet a, 0<=a<=3, de midterste 4 cifre repræsenterer tallet b, 0<=b<=15. Rækkerne i tabel S3 er nummereret fra 0 til 3, kolonnerne i tabel S3 er nummererede fra 0 til 15. Parret af tal (a, b) bestemmer tallet i skæringspunktet mellem række a og kolonne b. Den binære repræsentation af dette tal giver . I vores tilfælde er , , , og tallet defineret af parret (3,7) 7. Dens binære repræsentation er =0111. Funktionsværdien (32 bit ) opnås ved at permutere P påført en 32-bit blok . Permutationen P er givet i tabel 4. $B_3 = 101111$ $B'_3$ $B_{3}$ $B'_3$ $a=11_2=3$ $b=0111_2=7$ $B'_3$ $f(R_{i-1},k_i)$ $B'_1B'_2...B'_8$

Tabel 4. Permutation P

16	7	tyve	21	29	12	28	17
en	femten	23	26	5	atten	31	ti
2	otte	24	fjorten	32	27	3	9
19	13	tredive	6	22	elleve	fire	25

$f(R_{i-1},k_i) = P(B'_1B'_2...B'_8)$
Ifølge tabel 4 er de første fire bit af den resulterende vektor efter virkningen af funktionen f bit 16, 7, 20, 21 af vektoren $B'_1B'_2...B'_8$

Nøglegenerering $k_i$

Nøglerne opnås fra startnøglen (56 bit = 7 bytes eller 7 tegn i ASCII ) som følger. Bits tilføjes ved positionerne 8, 16, 24, 32, 40, 48, 56, 64 af nøglen , så hver byte indeholder et ulige antal enere. Dette bruges til at opdage fejl i nøgleudveksling og -lagring. Derefter foretages en permutation for den udvidede nøgle (bortset fra de tilføjede bits 8, 16, 24, 32, 40, 48, 56, 64). En sådan permutation er defineret i tabel 5. $k_i$ $k$ $k$

Tabel 5

57	49	41	33	25	17	9	en	58	halvtreds	42	34	26	atten	$C_{0}$
ti	2	59	51	43	35	27	19	elleve	3	60	52	44	36
63	55	47	39	31	23	femten	7	62	54	46	38	tredive	22	$D_0$
fjorten	6	61	53	45	37	29	21	13	5	28	tyve	12	fire

Denne permutation bestemmes af to blokke og 28 bit hver. De første 3 bit er bit 57, 49, 41 af den udvidede nøgle. Og de første tre bit er bit 63, 55, 47 af den udvidede nøgle. i=1,2,3 ... fås fra et eller to venstre cykliske skift i henhold til tabel 6. $C_{0}$ $D_0$ $C_{0}$ $D_0$ $C_i, D_i$ $C_{i-1}, D_{i-1}$

Tabel 6

jeg	en	2	3	fire	5	6	7	otte	9	ti	elleve	12	13	fjorten	femten	16
Skift nummer	en	en	2	2	2	2	2	2	en	2	2	2	2	2	2	en

Nøglen , i=1,...16 består af 48 bits valgt fra vektorbittene (56 bits ) ifølge tabel 7. Den første og anden bit er bit 14, 17 i vektoren $k_i$ $C_iD_i$ $k_i$ $C_iD_i$

Tabel 7

fjorten	17	elleve	24	en	5	3	28	femten	6	21	ti	23	19	12	fire
26	otte	16	7	27	tyve	13	2	41	52	31	37	47	55	tredive	40
51	45	33	48	44	49	39	56	34	53	46	42	halvtreds	36	29	32

Endelig permutation

Den endelige permutation virker på (hvor ) og er det omvendte af den oprindelige permutation. Den endelige permutation bestemmes af tabel 8. $\mathrm{IP}^{-1}$ ${\displaystyle T_{16}^{-1))$ ${\displaystyle T_{16}^{-1}=R_{16}+L_{16))$

Tabel 8. Omvendt permutation

\mathrm{IP}^{-1}

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

Dekrypteringsskema

Ved dekryptering af data udføres alle handlinger i omvendt rækkefølge. I 16 runder af dekryptering, i modsætning til krypteringen ved hjælp af den direkte transformation af Feistel-netværket , bruges den omvendte transformation af Feistel-netværket her.

$R_{i-1} = L_i$
$L_{i-1} = R_i \oplus f(L_i,k_i)$

Dekrypteringsskemaet er vist i fig.
Nøgle , i=16,…,1, funktion f, IP-permutation og er de samme som i krypteringsprocessen. Nøglegenereringsalgoritmen afhænger kun af brugerens nøgle, så de er identiske, når de dekrypteres. $k_i$ $IP^{-1}$

Brugsmåder af DES

DES kan bruges i fire tilstande.

Electronic Codebook Mode ( ECB ) : Almindelig brug af DES som blokchiffer . Den krypterede tekst er opdelt i blokke, hvor hver blok krypteres separat uden at interagere med andre blokke (se fig. 7).
Cipher Block Chaining Mode ( CBC - Cipher Block Chaining ) (se fig. 8). Hver næste blok i>=1, før kryptering tilføjes modulo 2 med den forrige blok med chiffertekst . Vektoren er den initiale vektor, den ændrer sig dagligt og holdes hemmelig. $M_{i}$ $C_{{i-1}}$ $C_{0}$
Cipher Feedback -tilstand ( se Fig.9). I CFB - tilstand produceres et blokagtigt gamma . Den indledende vektor er en synkroniseringsmeddelelse og er designet til at sikre, at forskellige datasæt krypteres forskelligt med den samme hemmelige nøgle. Synkroniseringsmeddelelsen sendes til modtageren i klartekst sammen med den krypterede fil. DES-algoritmen, i modsætning til de tidligere tilstande, bruges kun som kryptering (i begge tilfælde). $Z_0, Z_1,...$ $Z_i=DES_k(C_{i-1})$ $C_i = M_i \oplus Z_i$ $C_{0}$
Output feedback-tilstand ( OFB - Output Feedback ) (se fig. 10). I OFB-tilstanden genereres en blok "gamma" , i>=1. Tilstanden bruger også kun DES som kryptering (i begge tilfælde). $Z_0, Z_1,...$ $Z_i=DES_k(Z_{i-1}) C_i = M_i \oplus Z_i$

Fordele og ulemper ved tilstande:

I ECB- og OFB -tilstande fører forvrængning under transmissionen af en 64-bit blok af chiffertekst til forvrængning efter dekryptering af kun den tilsvarende åbne blok , så disse tilstande bruges til transmission over kommunikationskanaler med et stort antal forvrængninger. $C_i$ $M_i$

Kryptografisk styrke af DES-algoritmen

Den ikke-linearitet af transformationer i DES ved hjælp af kun S-bokse og brugen af svage S-bokse giver dig mulighed for at udøve kontrol over krypteret korrespondance. Valget af S-bokse kræver, at flere betingelser er opfyldt:

Hver linje i hver blok skal være en permutation af sættet {0, 1, 2, ..., 15}
S-bokse må ikke være en lineær eller affin funktion af deres argumenter.
En ændring i én bit ved indgangen til en S-boks skal ændre mindst to bits ved udgangen.
For hver S-boks og ethvert argument x skal værdien af S ( x ) og afvige med mindst to bit. $S(x\oplus 001100_2)$

På grund af det lille antal mulige nøgler (kun ), bliver det muligt at opregne dem udtømmende på højhastighedscomputere i realtid. I 1998 lykkedes det Electronic Frontier Foundation ved hjælp af en speciel DES-Cracker-computer at knække DES på 3 dage. $2^{56}$

Svage taster

Svage nøgler er nøgler k sådan, at , hvor x er en 64-bit blok. $DES_k(DES_k(x)) = x$

Der kendes 4 svage nøgler, de er anført i tabel 9. For hver svag nøgle er der faste punkter , det vil sige sådanne 64-bit blokke x for hvilke . $2^{32}$ $DES_k(x) = x$

Tabel 9. DES-Svage taster

Svage nøgler (hexadecimal)	$C_{0}$	$D_0$
0101-0101-0101-0101	$[0]^{28}$	$[0]^{28}$
FEFE-FEFE-FEFE-FEFE	$[1]^{28}$	$[1]^{28}$
1F1F-1F1F-0E0E-0E0E	$[0]^{28}$	$[1]^{28}$
E0E0-E0E0-F1F1-F1F1	$[1]^{28}$	$[0]^{28}$

$[0]^{28}$ betegner en vektor bestående af 28 nul bit.

Delvist svage taster

Der er svage og delvist svage nøgler i DES-algoritmen. Delvist svage nøgler er nøglepar sådan , at $(k_1, k_2)$ $DES_{k1}(DES_{k2}(x)) = x.$

Der er 6 delvist svage nøglepar, de er opført i tabel 10. For hver af de 12 delvist svage nøgler er der "anti-fikserede punkter", dvs. blokke x sådan, at $2^{32}$ $DES_k(x) = \tilde{x}.$

Tabel 10. Delvist svage taster

$C_{0}$	$D_0$	Par delvist svage nøgler	$C_{0}$	$D_0$
$[01]^{14}$	$[01]^{14}$	01FE-01FE-01FE-01FE,----FE01-FE01-FE01-FE01	$[10]^{14}$	$[10]^{14}$
$[01]^{14}$	$[01]^{14}$	1FE0-1FE0-1FE0-1FE0,----E0F1-E0F1-E0F1-E0F1	$[10]^{14}$	$[10]^{14}$
$[01]^{14}$	$[0]^{28}$	01E0-01E0-01F1-01F1,----E001-E001-F101-F101	$[10]^{14}$	$[0]^{28}$
$[01]^{14}$	$[1]^{28}$	1FFE-1FFE-0EFE-0EFE,----FE1F-FE1F-FE0E-FE0E	$[0]^{28}$	$[1]^{28}$
$[0]^{28}$	$[01]^{14}$	011F-011F-010E-010E,----1F01-1F01-0E01-0E01	$[0]^{28}$	$[10]^{14}$
$[1]^{28}$	$[01]^{14}$	E0FE-E0FE-F1FE-F1FE,----FEE0-FEE0-FEF1-FEF1	$[1]^{28}$	$[10]^{14}$

Kendte angreb mod DES

Tabel 11. Kendte angreb på DES.

Angrebsmetoder	Velkendte opdagelser tekster	Valgt åben tekster	Hukommelsesstørrelse	Antal operationer
Fuld søgning	qweqweqweqerqe	-	Mindre	$2^{55}$
Lineær kryptoanalyse	$2^{43}(85\%)$	-	Til tekst	$2^{43}$
Lineær kryptoanalyse	$2^{38}(10\%)$	-	Til tekst	$2^{50}$
Afvige. Krypteringsanalyse	-	$2^{47}$	Til tekst	$2^{47}$
Afvige. Krypteringsanalyse	$2^{55}$	-	Til tekst	$2^{55}$

Brute-force- metoden kræver et kendt par chiffertekst og dechifreringstekst, en lille mængde hukommelse, og dens udførelse kræver cirka trin. $2^{55}$
Differentiel kryptoanalyse - Biham og Shamir hævdede det første sådanne angreb på DES . Dette angreb kræver kryptering af klartekster valgt af angriberen og tager cirka 10 trin at fuldføre. Teoretisk set et bristepunkt, dette angreb er upraktisk på grund af overdrevne data mining-krav og kompleksiteten i at organisere et angreb på den valgte klartekst. Forfatterne til dette angreb, Biham og Shamir, udtalte selv, at de anser DES for sikkert for et sådant angreb. $2^{47}$ $2^{47}$
Lineær kryptoanalyse udviklet af Matsui. Denne metode giver dig mulighed for at gendanne en DES-nøgle ved at parse kendte klartekster og kræver cirka trin at fuldføre. Den første eksperimentelle DES-kryptanalyse baseret på Matsuis opdagelse blev udført med succes inden for 50 dage på 12 HP 9735-arbejdsstationer. $2^{43}$ $2^{43}$

Til lineær og differentiel kryptoanalyse kræves der en tilstrækkelig stor mængde hukommelse til at gemme udvalgte (kendte) klartekster, før angrebet begynder.

Forøgelse af DES's styrke

For at øge den kryptografiske styrke af DES vises flere muligheder: dobbelt DES ( 2DES ), tredobbelt DES ( 3DES ), DESX , G-DES .

2DES- og 3DES - metoderne er baseret på DES, men øger nøglernes længde (2DES - 112 bit, 3DES - 168 bit) og øger derfor den kryptografiske styrke .
3DES-skemaet har formen , hvor er nøglerne for hver DES-chiffer. Denne variant er kendt som i EEE, da de tre DES-operationer er kryptering. Der er 3 typer 3DES-algoritmer: $DES(k_3,DES(k_2,DES(k_1,M)))$ $k_1,k_2,k_3$

DES-EEE3 : Krypteret tre gange med 3 forskellige nøgler.
DES-EDE3 : 3DES kryptering-dekryptering-kryptering operationer med 3 forskellige nøgler.
DES-EEE2 og DES-EDE2 : Som ovenfor, bortset fra at den første og tredje operation bruger den samme tast.

Den mest populære type ved brug af 3DES er DES-EDE3, for hvilken algoritmen ser sådan ud: Kryptering : .

C = E_{k_3}(E^{-1}_{k_2}(E_{k_1}(P)))

Dekryptering :

P = E^{-1}_{k_1}(E_{k_2}(E^{-1}_{k_3}(C)))

Når du udfører 3DES-algoritmen, kan nøglerne vælges som følger:

$k_1,k_2,k_3$ uafhængig.
$k_1, k_2$ selvstændig og $k_1 = k_3$
$k_1=k_2=k_3$ .

DESX - metoden blev skabt af Ronald Rivest og formelt demonstreret af Killian og Rogaway. Denne metode er en hærdet version af DES, der understøttes af RSA Security-værktøjssættet. DESX adskiller sig fra DES ved, at hver bit af input DESX klartekst logisk summeres modulo 2 med 64 bit af en ekstra nøgle og derefter krypteret ved hjælp af DES-algoritmen. Hver bit af resultatet tilføjes også logisk modulo 2 til de andre 64 bit af nøglen. Hovedårsagen til at bruge DESX er en beregningsmæssig enkel måde at øge DES 's modstand mod brute-force- angreb markant .
G-DES- metoden blev udviklet af Schaumuller-Bichl for at forbedre ydeevnen af DES ved at øge størrelsen af chifferblokken. G-DES blev hævdet at være lige så sikker som DES. Biham og Shamir viste dog, at G-DES med de anbefalede parametre let knækkes, og med eventuelle ændringer i parametrene bliver chifferen endnu mindre sikker end DES.
En anden variant af DES bruger uafhængige undernøgler. Forskelligt fra DES, hvor DES, baseret på brugerens 56-bit private nøgle, opnår seksten 48-bit undernøgler til brug i hver af 16 runder, bruger denne version en 768-bit nøgle (opdelt i 16 48-bit undernøgler) ) i stedet for 16 afhængige 48-bit nøgler genereret af nøglegrafen for DES-algoritmen. Selvom det er klart, at brugen af uafhængige undernøgler i høj grad vil komplicere den komplette søgning af nøglen, er modstanden mod angreb ved differentiel eller lineær kryptoanalyse ikke meget højere end styrken af almindelig DES. Ifølge Biham kræver differentiel kryptoanalyse af DES med uafhængige undernøgler udvalgte klartekster, mens lineær kryptoanalyse kræver kendte klartekster. $2^{61}$ $2^{60}$

Ansøgning

DES var den amerikanske nationale standard i 1977-1980 , men i øjeblikket bruges DES (med en 56-bit nøgle) kun til ældre systemer, oftest ved at bruge dens mere kryptografisk stærke form ( 3DES , DESX ). 3DES er en enkel, effektiv erstatning for DES og betragtes nu som standarden. I den nærmeste fremtid vil DES og Triple DES blive erstattet af AES (Advanced Encryption Standard) algoritmen. DES-algoritmen bruges i vid udstrækning til at beskytte finansielle oplysninger: for eksempel understøtter THALES (Racal) HSM RG7000-modulet fuldt ud TripleDES- operationer til udstedelse og behandling af VISA , EuroPay og andre kreditkort. THALES (Racal) DataDryptor 2000 kanal scramblere bruger TripleDES til transparent kryptering af datastrømme. DES-algoritmen bruges også i mange andre THALES-eSECURITY enheder og løsninger.

Noter

↑ distributed.net: RSA DES II-1-projekt . Hentet 1. januar 2018. Arkiveret fra originalen 31. december 2017. (ubestemt)

Litteratur

A. P. Alferov, A. Yu. Zubov, A. S. Kuzmin, A. V. Cheremushkin Grundlæggende om kryptografi.
A. Menezes, Pvan Oorschot, S. Vanstone. Håndbog i anvendt kryptografi .
Semenov Yu. A. DES algoritme .
Forespørgsel til DES

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