AES (krypteringsstandard)

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 7. marts 2021; checks kræver 20 redigeringer .
AES, Rijndael-AES, Rijndael
Skaber Vincent Rayman
Yoan Dymen
Oprettet 1998 _
Nøglestørrelse 128/192/256 bit
Blokstørrelse 128 bit
Antal runder 10/12/14 (afhænger af nøglestørrelse)
Type Substitution-permutation netværk
 Mediefiler på Wikimedia Commons

AES ( Advanced Encryption Standard ; også Rijndael , [rɛindaːl] -   reindal ) er en symmetrisk blokchifferalgoritme (blokstørrelse 128 bit, nøgle 128/192/256 bit), vedtaget som en krypteringsstandard af den amerikanske regering som et resultat af AES konkurrence . Denne algoritme er blevet godt analyseret og er nu meget brugt, som det var tilfældet med dens forgænger DES . Det amerikanske National Institute of Standards and Technology (NIST) offentliggjorde AES-specifikationen den 26. november 2001, efter en femårig periode, hvor 15 kandidater blev oprettet og evalueret. Den 26. maj 2002 blev AES annonceret som krypteringsstandarden. Fra 2009 er AES en af ​​de mest udbredte symmetriske krypteringsalgoritmer [1] [2] . Understøttelse af AES-acceleration blev introduceret af Intel til x86- processorfamilien startende med Arrandale i 2010 og senere på Sandy Bridge-processorer ; AMD har været hos Bulldozer siden 2011.  

Historien om AES

Den 2. januar 1997 annoncerer NIST [3] sin hensigt om at vælge en efterfølger til DES , som har været den amerikanske standard siden 1977 . Den 2. oktober 2000 blev det offentliggjort, at vinderen af ​​konkurrencen var Rijndael-algoritmen [4] , og standardiseringsproceduren begyndte. Den 28. februar 2001 blev udkastet offentliggjort, og den 26. november 2001 blev AES accepteret som FIPS 197. Et historisk tilbageblik på konkurrencen kan findes på NISTs hjemmeside [5] .

Beskrivelse af AES

Definitioner og hjælpeprocedurer

Definitioner
blok sekvensen af ​​bit, der udgør input, output, tilstand og rundnøgle. Blok kan også forstås som en sekvens af bytes
Chiffernøgle en hemmelig kryptografisk nøgle, der bruges af nøgleudvidelsesproceduren til at producere et sæt runde nøgler; kan repræsenteres som et rektangulært byte-array med fire rækker og Nk - kolonner
Chiffertekst krypteringsalgoritme output
nøgleudvidelse procedure for generering af runde nøgler fra Cipher Key
Rund nøgle Runde nøgler fås fra Cipher Key ved hjælp af Key Expansion-proceduren. De anvendes til staten ved kryptering og dekryptering
Stat mellemliggende krypteringsresultat, som kan repræsenteres som et rektangulært byte-array med 4 rækker og Nb - kolonner
S kasse ikke-lineær substitutionstabel, der bruges i flere byte-substitutionstransformationer og i Key Expansion-proceduren for en-til-en substitution af en byteværdi. Den forudberegnede S-boks kan ses nedenfor
NB antallet af kolonner (32-bit ord), der udgør staten . For AES Nb = 4
Nk antallet af 32-bit ord, der udgør krypteringsnøglen. For AES Nk = 4, 6 eller 8
Ingen. antallet af runder, som er en funktion af Nk og Nb . For AES Nr = 10, 12, 14
Rcon[] et array, der består af bits af et 32-bit ord og er konstant for en given runde. Den forudberegnede Rcon[] kan ses nedenfor

S kasse

sbox = matrix{ 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };

Omvendt S-boks for procedure InvSubBytes

InvSbox = array{ 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };

Rcon[]

Rcon = matrix{ matrix{0x00, 0x00, 0x00, 0x00}, matrix{0x01, 0x00, 0x00, 0x00}, matrix{0x02, 0x00, 0x00, 0x00}, matrix{0x04, 0x00, 0x00, 0x00}, matrix{0x08, 0x00, 0x00, 0x00}, matrix{0x10, 0x00, 0x00, 0x00}, matrix{0x20, 0x00, 0x00, 0x00}, matrix{0x40, 0x00, 0x00, 0x00}, matrix{0x80, 0x00, 0x00, 0x00}, matrix{0x1b, 0x00, 0x00, 0x00}, matrix{0x36, 0x00, 0x00, 0x00} }; Hjælpeprocedurer
AddRoundKey() transformation under kryptering og omvendt kryptering, hvor Round Key XOR er c State. Længden af ​​RoundKey er lig med størrelsen af ​​staten (det vil sige, hvis Nb = 4, så er længden af ​​RoundKey 128 bit eller 16 bytes)
InvMixColumns() transformation ved dekryptering, som er det modsatte af MixColumns()
InvShiftRows() transformation ved dekryptering, som er det modsatte af ShiftRows()
InvSubBytes() transformation ved dekryptering, som er det omvendte af SubBytes()
MixColumns() krypteringstransformation, der tager alle State-kolonner og blander deres data (uafhængigt af hinanden) for at få nye kolonner
RotWord() en funktion, der bruges i nøgleudvidelsesproceduren, der tager et 4-byte ord og går gennem det
ShiftRows() krypteringstransformationer, der behandler staten, og skifter cyklisk de sidste tre linjer i staten med forskellige værdier
SubBytes() krypteringstransformationer, der behandler staten ved hjælp af en ikke-lineær bytesubstitutionstabel (S-boks), der anvender den uafhængigt på hver byte i staten
Underord() funktion, der bruges i Key Expansion-proceduren, der tager et fire-byte-ord som input og ved at anvende en S-boks til hver af de fire bytes, producerer et output-ord

Kryptering

AES er en standard baseret på Rijndael-algoritmen. For AES er længden af ​​input (blok med inputdata) og tilstand (tilstand) konstant og lig med 128 bit, og længden af ​​chiffernøglen K er 128, 192 eller 256 bit. Samtidig tillader den originale Rijndael-algoritme en nøglelængde og blokstørrelse fra 128 til 256 bit med et trin på 32 bit. For at angive de valgte længder af input, State og Cipher Key i 32-bit ord, bruges notationen Nb = 4 for henholdsvis input og State, Nk = 4, 6, 8 for Cipher Key for forskellige nøglelængder.

Ved starten af ​​kryptering kopieres input til State-arrayet med reglen , for og . Derefter anvendes AddRoundKey()-proceduren på staten, og derefter gennemgår staten transformationsproceduren (runde) 10, 12 eller 14 gange (afhængigt af nøglelængden), mens den tager højde for, at den sidste runde er lidt anderledes end de foregående. Som et resultat, efter afslutningen af ​​den sidste transformationsrunde, kopieres State til output i henhold til reglen , for og .

Separate transformationer SubBytes(), ShiftRows(), MixColumns() og AddRoundKey() håndterer tilstanden. Array w[] - indeholder nøgleskemaet.

Cipher(byte ind[4*Nb], byte ud[4*Nb], ord w[Nb*(Nr+1)]) begynde bytetilstand[4,Nb] tilstand = i AddRoundKey(tilstand, w[0, Nb-1]) for runde = 1 trin 1 til Nr-1 Subbytes (tilstand) ShiftRows(tilstand) Blandkolonner (tilstand) AddRoundKey(tilstand, w[rund*Nb, (rund+1)*Nb-1]) ende for Subbytes (tilstand) ShiftRows(tilstand) AddRoundKey(tilstand, w[Nr*Nb, (Nr+1)*Nb-1]) ud = tilstand ende

Fig1. Pseudokode til Cipher

SubBytes()

SubBytes()-proceduren behandler hver tilstandsbyte uafhængigt ved at udføre en ikke-lineær bytesubstitution ved hjælp af en substitutionstabel (S-box). Denne operation sikrer ikke-lineariteten af ​​krypteringsalgoritmen. Opbygning af en S-boks består af to trin. Først tages det gensidige af Galois-feltet . For alle operationer i dette felt bruges et irreducerbart polynomium . For det andet, for hver byte b, der udgør S-boksen, anvendes følgende operation:

hvor , og hvor er den i-te bit af b, og  er den i-te bit af konstanten . Dette giver beskyttelse mod angreb baseret på simple algebraiske egenskaber.

ShiftRows()

ShiftRowsarbejder med State-strenge. Med denne transformation forskydes statuslinjerne cyklisk vandret med r bytes afhængigt af linjenummeret. For nul-rækken, r = 0, for den første række, r = 1 B osv. Hver kolonne i output-tilstanden efter anvendelse af proceduren ShiftRowsbestår således af bytes fra hver kolonne i den oprindelige tilstand. For Rijndael-algoritmen er strengoffsetmønsteret for 128- og 192-bit strenge det samme. For en 256-bit blok adskiller den sig dog fra de foregående ved, at 2., 3. og 4. række er forskudt med henholdsvis 1, 3 og 4 bytes. Denne note gælder ikke for AES, da den kun bruger Rijndael-algoritmen med 128-bit blokke, uanset nøglestørrelse.

MixColumns()

Proceduren MixColumnsblander de fire bytes i hver tilstandskolonne ved hjælp af en reversibel lineær transformation. MixColumnsbehandler tilstande efter kolonner og behandler hver af dem som et polynomium af tredje grad. Disse polynomier ganges [6] i modulo med et fast polynomium . Sammen med introducerer diffusion i chifferen. ShiftRows MixColumns

AddRoundKey()

AddRoundKey RoundKeyKombinerer med State i hver runde procedure . For hver runde Roundkey er opnået fra CipherKeyc ved hjælp af proceduren KeyExpansion; hver rundnøgle har samme størrelse som staten. Proceduren udfører en bitvis XOR af hver byte Statemed hver byte RoundKey.

Nøglebehandlingsalgoritme

Nøglebehandlingsalgoritmen består af to procedurer:

  • Round Key Generation Algoritme (nøgleudvidelsesalgoritme)
  • Algoritme til at vælge en rund nøgle (iterationsnøgle)

Algoritme til generering af runde nøgler

AES-algoritmen, ved at bruge KeyExpansion()-proceduren og tilføre den Cipher Key, K, henter nøglerne til alle runder. Der er Nb*(Nr + 1) ord i alt: indledningsvis har algoritmen brug for et sæt Nb-ord, og hver af Nr-runderne har brug for Nb-nøgledatasæt. Det resulterende array af nøgler til runder er betegnet som , . KeyExpansion()-algoritmen er vist i pseudokoden nedenfor.

Funktionen SubWord() tager et fire-byte inputord og anvender en S-boks til hver af de fire bytes. Det, der skete, føres til udgangen. RotWord() tager et ord som input , som det går igennem og returnerer . Den række af ord, der er konstant for denne runde, , indeholder værdierne af , hvor x = {02}, og er en potens af ( starter fra 1).

På figuren kan du se, at de første ord i den udvidede nøgle er fyldt med Cipher Key. I hvert efterfølgende ord, , sættes værdien opnået under XOR-operationen og , disse XOR for de foregående og Nk-positioner før ordene. For ord, hvis position er et multiplum af Nk, anvendes en transformation til w[i-1] før XOR, efterfulgt af en XOR med den runde konstant Rcon[i]. Ovenstående transformation består af en cirkulær forskydning af bytes i et ord (RotWord()) efterfulgt af en SubWord() procedure - det samme som SubBytes(), kun input og output data vil være ordstørrelse.

Det er vigtigt at bemærke, at KeyExpansion()-proceduren for en 256-bit chiffernøgle er en smule anderledes end dem for 128-bit og 192-bit chiffernøgler. Hvis og er et multiplum af , så anvendes SubWord() før XOR'a.

KeyExpansion(byte-nøgle[4 * Nk], ord w[Nb * (Nr+1)], Nk) begynde ord temp i = 0; mens (i < Nk) w[i] = ord(tast[4*i], nøgle[4*i+1], nøgle[4*i+2], nøgle[4*i+3]) i = i + 1 slutte mens i = Nk mens(i < Nb * (Nr+1)) temp = w[i - 1] hvis (i mod Nk = 0) temp = SubWord(RotWord(temp)) xor Rcon[i / Nk] ellers hvis (Nk > 6 og i mod Nk = 4) temp = Underord(temp) Afslut Hvis w[i] = w[i - Nk] xor temp i = i + 1 slutte mens ende

Pseudokode til nøgleudvidelse

Dekryptering

InvCipher(byte ind[4 * Nb], byte ud[4 * Nb], ord w[Nb * (Nr+1)]) begynde bytetilstand[4, Nb] tilstand = i AddRoundKey(tilstand, w[Nr * Nb, Nb * (Nr+1) - 1]) for runde = Nr - 1 trin -1 ned til 1 InvShiftRows(tilstand) InvSubBytes(stat) TilføjRoundKey(tilstand, w[Nb * rund, Nb * (rund+1) - 1]) InvMixColumns(tilstand) ende for InvShiftRows(tilstand) InvSubBytes(stat) AddRoundKey(tilstand, w[0, Nb - 1]) ud = tilstand ende

Pseudokode for omvendt chiffer

Algoritme for rundnøglevalg

Ved hver iteration vælges den runde nøgle til AddRoundKey- operationen fra arrayet , startende fra element til .

Varianter af algoritmen

Baseret på Rijndael-algoritmen, der ligger til grund for AES, implementeres alternative kryptoalgoritmer. Blandt de mest berømte er deltagerne i Nessie : Anubis -konkurrencen om involutioner, forfattet af Vincent Rayman og en forbedret version af chifferen - Grand Cru af Johan Borst.

Sikkerhed

I juni 2003 fastslog US National Security Agency, at AES var stærk nok til at blive brugt til at beskytte klassificerede oplysninger .  Op til HEMMELIG niveau var det tilladt at bruge nøgler på 128 bit, til TOP SECRET niveau krævedes nøgler på 192 og 256 bit [7] .

XSL-angreb

I modsætning til de fleste andre cifre har AES en simpel matematisk beskrivelse. Dette bekymrede blandt andre Niels Ferguson , som bemærkede i sit arbejde, at sikkerheden af ​​en chiffer er baseret på en ny utestet antagelse om kompleksiteten af ​​at løse visse typer ligninger ( engelsk  “The security of Rijndael afhænger af en ny og utestet hårdhedsantagelse : det er beregningsmæssigt umuligt at løse ligninger af denne type" ) [8] [9] , samt Bruce Schneier, der skrev i en fælles bog med Niels:

Vi har én kritik af AES: vi stoler ikke rigtig på dets sikkerhed. Det, der bekymrer os mest ved AES, er dens simple algebraiske struktur... Ingen anden blokchiffer har en så simpel algebraisk repræsentation. Vi har ingen idé om, om dette fører til et angreb eller ej, men at ikke vide dette er grund nok til at være skeptisk over for at bruge AES.

Originaltekst  (engelsk)[ Visskjule] Vi har én kritik af AES: vi stoler ikke helt på sikkerheden... Det, der bekymrer os mest ved AES, er dens simple algebraiske struktur... Ingen anden blokchiffer, vi kender til, har så simpel en algebraisk repræsentation. Vi aner ikke, om dette fører til et angreb eller ej, men det er grund nok til at være skeptisk over for brugen af ​​AES - Niels Ferguson , Bruce Schneier Praktisk kryptografi - 2003 - pp. 56-57

Nicolas Courtois og Josef  Pieprzyk publiceredeen artikel i 2002, hvor de beskrev et teoretisk angreb, de kaldte XSL- angrebet ( eXtended Sparse Linearization ), som kunne tillade at bryde AES-cifre og Serpent [10] [11] . Men resultaterne af arbejdet blev ikke accepteret af alle optimistisk:   

Jeg mener, at der er en fejl i Courtois-Pepshiks arbejde. De overvurderede antallet af lineært uafhængige ligninger. Som et resultat har de ikke nok lineære ligninger til at løse systemet, og den [specificerede] metode kan ikke knække Rijndael. Det har en vis værdi og er værd at udforske, men det hacker ikke Rijndael i sin nuværende form.

Originaltekst  (engelsk)[ Visskjule] Jeg mener, at Courtois-Pieprzyks arbejde er mangelfuldt. De overtæller antallet af lineært uafhængige ligninger. Resultatet er, at de faktisk ikke har nok lineære ligninger til at løse systemet, og metoden bryder ikke Rijndael... Metoden har en vis fordel og er værd at undersøge, men den bryder ikke Rijndael, som den står. — Don Coppersmith , kommentar til blogindlæg af Bruce Schneier

På siden dedikeret til diskussionen af ​​NESSIE- konkurrencen , i slutningen af ​​2002, udtalte en af ​​forfatterne til chifferen, Vincent Rayman, at XSL-angrebet bare er en drøm ( Engelsk  XSL-angrebet er ikke et angreb. Det er en drøm ) (dette synspunkt blev senere gentaget i 2004 ved den 4. AES-konference i Bonn ). Til dette svarede Courtois, at denne drøm kunne blive et mareridt for forfatteren af ​​AES ( engelsk  Det kan også være en meget dårlig drøm og blive til et mareridt ) [12] (spil med ord: drøm oversættes både som en drøm og som en drøm . Mareridt oversættes som mareridt, mareridt ).

I 2003 udgav Sean Murphy og Matt Robshaw et  papir, hvori ( forudsat at resultaterne af Courtois og Pepshik er korrekte) begrundede muligheden for at angribe AES-algoritmen, hvilket reducerede antallet af operationer til cracking fra 2128 til 2100 . På den 4. AES-konference viste Ilia Toli og Alberto Zanoni imidlertid , at Murphy og Robshaws arbejde var forkert [ 13] . Senere, i 2007, viste Chu-Wee Lim og Khoongming Khoo også, at dette angreb ikke kan fungere som beskrevet [14 ] .    

Sidekanalangreb

Sidekanalangreb er ikke relateret til chifferens matematiske funktioner, men bruger visse implementeringsfunktioner i systemer, der bruger disse chiffere for at afsløre delvist eller helt hemmelige data, inklusive nøglen. Der er flere lignende angreb på systemer, der bruger AES-algoritmen.

I april 2005 offentliggjorde Daniel J. Bernstein  et papir, der beskrev et angreb, der bruger information om udførelsestiden for hver krypteringsoperation til at knække [15] . Dette angreb krævede over 200 millioner udvalgte chiffertekster for at finde nøglen [16] .

I oktober 2005 præsenterede Doug Arne Osvik, Adi Shamir og Eran Trumer et papir, der beskrev flere angreb, der bruger tid på at finde en nøgle. Et af de præsenterede angreb fik nøglen efter 800 krypteringsoperationer. Angrebet krævede, at kryptanalytikeren kunne køre programmer på det samme system, hvor krypteringen blev udført [17] .

I december 2009 blev der udgivet et papir, hvor brugen af ​​differentiel fejlanalyse ( eng.  Differential Fault Analysis ), kunstigt skabt i tilstandsmatrixen ved 8. krypteringsrunde, gjorde det muligt at genskabe nøglen i 2 32 operationer [18 ] .

Se også

Noter

  1. Chekanovs laboratorium. Intel Core i5 (Clarkdale): Analyse af AES-krypteringshardwareacceleration . THG (19. januar 2010). - "den mest populære standard for symmetrisk kryptering i IT-verdenen." Hentet 14. november 2010. Arkiveret fra originalen 26. februar 2012.
  2. Biryukov, Alex og Khovratovich, Dmitry. Related-key Cryptanalysis of the Full AES-192 and AES-256  (engelsk)  // Advances in Cryptology - ASIACRYPT 2009. - Springer Berlin / Heidelberg, 2009. - Vol. 5912 . - S. 1-18 . - doi : 10.1007/978-3-642-10366-7_1 . Arkiveret fra originalen den 18. december 2010.
  3. Arkiveret kopi (link ikke tilgængeligt) . Hentet 7. december 2006. Arkiveret fra originalen 6. november 2006. 
  4. NIST-fejlside arkiveret 28. september 2010.
  5. Bounce to index.html Arkiveret 17. juli 2014.
  6. http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf Arkiveret 7. april 2015 på Wayback Machine "5.1.3 MixColumns() Transformation .. Søjlerne betragtes som polynomier over GF( 2^8) og ganget modulo x^4 + 1 med et fast polynomium a(x), givet ved a(x) = {03}x³ + {01}x² + {01}x + {02}."
  7. ↑ National politik om brugen af ​​den avancerede krypteringsstandard (AES) til at beskytte nationale sikkerhedssystemer og nationale sikkerhedsoplysninger  . Udvalg for nationale sikkerhedssystemer (juni 2003). Dato for adgang: 27. oktober 2010. Arkiveret fra originalen 19. februar 2012.
  8. James McLaughlin. XSL-kontroversen // En undersøgelse af blokchifferkrypteringsteknikker . - Print. - York: University of York, 2009.  (utilgængeligt link)
  9. Niels Ferguson, Richard Schroeppel og Doug Whiting. En simpel algebraisk repræsentation af Rijndael  //  Selected Areas in Cryptography, Proc. SAC 2001, Lecture Notes in Computer Science #2259. - Springer Verlag, 2001. - S. 103-111 . Arkiveret fra originalen den 16. januar 2016.
  10. Bruce Schneier. Crypto-Gram  nyhedsbrev . Schneier om sikkerhed (15. september 2002). Dato for adgang: 27. oktober 2010. Arkiveret fra originalen 19. februar 2012.
  11. Nicolas Courtois, Josef Pieprzyk. Krypteringsanalyse af blokcifre med overdefinerede ligningssystemer  //  Fremskridt inden for kryptologi - ASIACRYPT 2002 8. internationale konference om teorianvendelse af kryptologi og informationssikkerhed Queenstown, New Zealand, 1.-5. december 2002 Proceedings. Forelæsningsnotater i datalogi (2501). - Springer, 2002. - S. 267-287 . - doi : 10.1007/3-540-36178-2 . Arkiveret 26. oktober 2020.
  12. NESSIE Diskussionsforum
  13. Ilia Toli, Alberto Zanoni. En algebraisk fortolkning af AES-128   // Proc . af AES-konferencen. - 2005. - Bd. 2005 . - S. 84-97 . - doi : 10.1007/11506447_8 .  (utilgængeligt link)
  14. Chu-wee Lim, Khoongming Khoo. En analyse af XSL anvendt på BES  //  Hurtig softwarekryptering. - Heidelberg: Springer Berlin / Heidelberg, 2007. - Vol. 4593 . - S. 242-253 . - doi : 10.1007/978-3-540-74619-5_16 .  (utilgængeligt link)
  15. Daniel J. Bernstein. Cache-timing angreb på  AES . - 2004. Arkiveret 17. september 2008.
  16. Bruce Schneier. AES timing  angreb . Schneier om sikkerhed (17. maj 2005). Dato for adgang: 27. oktober 2010. Arkiveret fra originalen 19. februar 2012.
  17. Dag Arne Osvik; Adi Shamir og Eran Tromer. Cache-angreb og modforanstaltninger: Case of AES  // Emner i kryptologi - CT-RSA 2006, The Cryptographers' Track at the RSA Conference. - Springer-Verlag, 2005. - S. 1-20. Arkiveret 25. november 2020.
  18. Dhiman Saha, Debdeep Mukhopadhyay, Dipanwita Roy Chowdhury. Et diagonalt fejlangreb på Advanced Encryption Standard   // Cryptology ePrint Archive . - 2009. Arkiveret den 6. august 2020.

Litteratur

Links