AES (krypteringsstandard)

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 7 mars 2021; kontroller kräver 20 redigeringar .
AES, Rijndael-AES, Rijndael
Skapare Vincent Rayman
Yoan Dymen
Skapad 1998 _
Nyckelstorlek 128/192/256 bitar
Block storlek 128 bitar
Antal omgångar 10/12/14 (beror på nyckelstorlek)
Sorts Substitution-permutationsnätverk
 Mediafiler på Wikimedia Commons

AES ( Advanced Encryption Standard ; även Rijndael , [rɛindaːl] -   reindal ) är en symmetrisk blockchifferalgoritm (blockstorlek 128 bitar, nyckel 128/192/256 bitar), antagen som en krypteringsstandard av den amerikanska regeringen som ett resultat av AES-tävling . Denna algoritm har analyserats väl och används nu flitigt, vilket var fallet med dess föregångare DES . US National Institute of Standards and Technology (NIST) publicerade AES-specifikationen den 26 november 2001, efter en femårsperiod under vilken 15 kandidater skapades och utvärderades. Den 26 maj 2002 tillkännagavs AES som krypteringsstandard. Från och med 2009 är AES en av de mest använda symmetriska krypteringsalgoritmerna [1] [2] . Stöd för AES-acceleration introducerades av Intel till x86 -processorfamiljen från och med Arrandale 2010 och senare på Sandy Bridge-processorer ; AMD har funnits med Bulldozer sedan 2011.  

Historia om AES

Den 2 januari 1997 tillkännager NIST [3] sin avsikt att välja en efterträdare till DES , som har varit den amerikanska standarden sedan 1977 . Den 2 oktober 2000 tillkännagavs att vinnaren av tävlingen var Rijndael-algoritmen [4] , och standardiseringsproceduren började. Den 28 februari 2001 publicerades utkastet och den 26 november 2001 accepterades AES som FIPS 197. En historisk retrospektiv av tävlingen finns på NISTs webbplats [5] .

Beskrivning av AES

Definitioner och hjälpprocedurer

Definitioner
blockera sekvensen av bitar som utgör input, output, state och round key. Block kan också förstås som en sekvens av bytes
Chiffernyckel en hemlig kryptografisk nyckel som används av nyckelexpansionsproceduren för att producera en uppsättning runda nycklar; kan representeras som en rektangulär byte-array med fyra rader och Nk- kolumner
Chiffertext utdata för krypteringsalgoritm
nyckelexpansion procedur för att generera runda nycklar från Cipher Key
Rund nyckel Runda nycklar erhålls från Cipher Key med hjälp av Key Expansion-proceduren. De tillämpas på staten vid kryptering och dekryptering
stat mellanliggande krypteringsresultat, som kan representeras som en rektangulär byte-array med 4 rader och Nb- kolumner
S box icke-linjär substitutionstabell som används i flera bytesubstitutionstransformationer och i Key Expansion-proceduren för en-till-en-ersättning av ett bytevärde. Den förberäknade S-boxen kan ses nedan
Obs antalet kolumner (32-bitars ord) som utgör staten . För AES Nb = 4
Nk antalet 32-bitars ord som utgör krypteringsnyckeln. För AES Nk = 4, 6 eller 8
Nej. antalet omgångar, som är en funktion av Nk och Nb . För AES Nr = 10, 12, 14
Rcon[] en array som består av bitarna i ett 32-bitars ord och är konstant för en given omgång. Den förberäknade Rcon[] kan ses nedan

S box

sbox = array{ 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 };

Omvänd S-box för proceduren 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 = array{ array{0x00, 0x00, 0x00, 0x00}, array{0x01, 0x00, 0x00, 0x00}, array{0x02, 0x00, 0x00, 0x00}, array{0x04, 0x00, 0x00, 0x00}, array{0x08, 0x00, 0x00, 0x00}, array{0x10, 0x00, 0x00, 0x00}, array{0x20, 0x00, 0x00, 0x00}, array{0x40, 0x00, 0x00, 0x00}, array{0x80, 0x00, 0x00, 0x00}, array{0x1b, 0x00, 0x00, 0x00}, array{0x36, 0x00, 0x00, 0x00} }; Hjälpförfaranden
AddRoundKey() transformation under kryptering och omvänd kryptering, där Round Key XOR är c ​​State. Längden på RoundKey är lika med storleken på State (det vill säga om Nb = 4, då är RoundKeys längd 128 bitar eller 16 byte)
InvMixColumns() transformation vid dekryptering, vilket är motsatsen till MixColumns()
InvShiftRows() transformation vid dekryptering, vilket är motsatsen till ShiftRows()
InvSubBytes() transformation vid dekryptering, vilket är inversen av SubBytes()
MixColumns() krypteringstransformation som tar alla State-kolumner och blandar deras data (oberoende av varandra) för att få nya kolumner
RotWord() en funktion som används i Key Expansion-proceduren som tar ett 4-byte ord och cyklar igenom det
ShiftRows() krypteringstransformationer som bearbetar staten, cykliskt förskjuter de tre sista raderna av staten med olika värden
SubBytes() krypteringstransformationer som behandlar staten med hjälp av en icke-linjär bytesubstitutionstabell (S-box), som applicerar den oberoende på varje byte i staten
SubWord() funktion som används i Key Expansion-proceduren som tar ett ord på fyra byte som indata och, genom att applicera en S-box på var och en av de fyra byten, producerar ett utdataord

Kryptering

AES är en standard baserad på Rijndael-algoritmen. För AES är längden på indata (block med indata) och tillstånd (tillstånd) konstant och lika med 128 bitar, och längden på chiffernyckeln K är 128, 192 eller 256 bitar. Samtidigt tillåter den ursprungliga Rijndael-algoritmen en nyckellängd och blockstorlek från 128 till 256 bitar med ett steg på 32 bitar. För att beteckna de valda längderna av indata, tillstånd och chiffernyckel i 32-bitars ord, används notationen Nb = 4 för inmatning och tillstånd, Nk = 4, 6, 8 för chiffernyckel, respektive, för olika nyckellängder.

I början av krypteringen kopieras indata till State-arrayen med regeln , för och . Därefter tillämpas AddRoundKey()-proceduren på staten, och sedan går staten igenom transformationsproceduren (runda) 10, 12 eller 14 gånger (beroende på nyckelns längd), samtidigt som man tar hänsyn till att den sista omgången skiljer sig något från de tidigare. Som ett resultat, efter slutförandet av den sista omvandlingen, kopieras State till utdata enligt regeln , för och .

Separata transformationer SubBytes(), ShiftRows(), MixColumns() och AddRoundKey() hanterar tillståndet. Array w[] - innehåller nyckelschemat.

Chiffer(byte in[4*Nb], byte ut[4*Nb], ord w[Nb*(Nr+1)]) Börja byte state[4,Nb] tillstånd = in AddRoundKey(tillstånd, w[0, Nb-1]) för varv = 1 steg 1 till Nr-1 SubBytes(tillstånd) ShiftRows(tillstånd) MixColumns(tillstånd) AddRoundKey(tillstånd, w[round*Nb, (round+1)*Nb-1]) slut för SubBytes(tillstånd) ShiftRows(tillstånd) AddRoundKey(tillstånd, w[Nr*Nb, (Nr+1)*Nb-1]) ut = tillstånd slutet

Figur 1. Pseudokod för Chiffer

SubBytes()

SubBytes()-proceduren behandlar varje tillståndsbyte oberoende genom att utföra en icke-linjär bytesubstitution med användning av en substitutionstabell (S-box). Denna operation säkerställer icke-linjäriteten hos krypteringsalgoritmen. Att bygga en S-box består av två steg. Först tas det ömsesidiga av Galois-fältet . För alla operationer i detta fält används ett irreducerbart polynom . För det andra, för varje byte b som utgör S-boxen, tillämpas följande operation:

där , och var är den i:te biten av b, och  är den i:te biten av konstanten . Detta ger skydd mot attacker baserat på enkla algebraiska egenskaper.

ShiftRows()

ShiftRowsfungerar med State strängar. Med denna transformation förskjuts statusraderna cykliskt horisontellt med r byte beroende på radnumret. För nollraden, r = 0, för den första raden, r = 1 B osv. Således ShiftRowsbestår varje kolumn i utgångstillståndet efter tillämpning av proceduren av bytes från varje kolumn i initialtillståndet. För Rijndael-algoritmen är strängoffsetmönstret för 128- och 192-bitars strängar detsamma. Men för ett 256-bitars block skiljer det sig från de tidigare genom att raden 2:a, 3:e och 4:e raden förskjuts med 1, 3 respektive 4 byte. Denna anmärkning gäller inte för AES, eftersom den bara använder Rijndael-algoritmen med 128-bitars block, oavsett nyckelstorlek.

MixColumns()

Proceduren MixColumnsblandar de fyra byten i varje tillståndskolumn med användning av en reversibel linjär transformation. MixColumnsbehandlar tillstånd efter kolumner och behandlar var och en av dem som ett polynom av tredje graden. Dessa polynom multipliceras [6] i modulo med ett fast polynom . Tillsammans med introducerar diffusion i chifferet. ShiftRows MixColumns

AddRoundKey()

AddRoundKey RoundKeyKombinerar med State i varje omgångsprocedur . För varje omgång Roundkey erhålls från CipherKeyc med hjälp av proceduren KeyExpansion; varje RoundKey har samma storlek som staten. Proceduren utför en bitvis XOR för varje byte Statemed varje byte RoundKey.

Nyckelbearbetningsalgoritm

Nyckelbearbetningsalgoritmen består av två procedurer:

  • Round Key Generation Algoritm (Key Expansion Algorithm)
  • Algoritm för att välja en rund nyckel (iterationsnyckel)

Algoritm för att generera runda nycklar

AES-algoritmen, som använder KeyExpansion()-proceduren och matar den med Cipher Key, K, erhåller nycklarna för alla omgångar. Det finns Nb*(Nr + 1) ord totalt: initialt behöver algoritmen en uppsättning Nb-ord, och var och en av Nr-omgångarna behöver Nb-nyckeldatauppsättningar. Den resulterande uppsättningen av nycklar för rundor betecknas som , . KeyExpansion()-algoritmen visas i pseudokoden nedan.

Funktionen SubWord() tar ett inmatningsord på fyra byte och tillämpar en S-box på var och en av de fyra byten. Det som hände matas till utgången. RotWord() tar ett ord som indata , som det bläddrar igenom och returnerar . Arrayen av ord som är konstant för denna omgång, , innehåller värdena på , där x = {02}, och är en potens av ( börjar från 1).

Från figuren kan du se att de första orden i den utökade nyckeln är fyllda med Chiffernyckel. I varje efterföljande ord, , sätts värdet som erhållits under XOR-operationen och , de XOR för de föregående och Nk-positionerna före orden. För ord vars position är en multipel av Nk, tillämpas en transformation på w[i-1] före XOR, följt av en XOR med den runda konstanten Rcon[i]. Ovanstående transformation består av en cirkulär förskjutning av byte i ett ord (RotWord()) följt av en SubWord()-procedur - samma som SubBytes(), endast in- och utdata kommer att ha ordstorlek.

Det är viktigt att notera att KeyExpansion()-proceduren för en 256-bitars chiffernyckel skiljer sig något från de för 128-bitars och 192-bitars chiffernycklar. Om och är en multipel av , så tillämpas SubWord() på före XOR'a.

KeyExpansion(byte-nyckel[4 * Nk], ord w[Nb * (Nr+1)], Nk) Börja ord temp i = 0; medan (i < Nk) w[i] = ord(nyckel[4*i], tangent[4*i+1], tangent[4*i+2], tangent[4*i+3]) i = i + 1 avsluta medan i = Nk while(i < Nb * (Nr+1)) temp = w[i - 1] if (i mod Nk = 0) temp = SubWord(RotWord(temp)) xor Rcon[i / Nk] annars om (Nk > 6 och i mod Nk = 4) temp = SubWord(temp) sluta om w[i] = w[i - Nk] xor temp i = i + 1 avsluta medan slutet

Pseudokod för nyckelexpansion

Dekryptering

InvCipher(byte in[4 * Nb], byte ut[4 * Nb], ord w[Nb * (Nr+1)]) Börja byte tillstånd[4, Nb] tillstånd = in AddRoundKey(tillstånd, w[Nr * Nb, Nb * (Nr+1) - 1]) för runda = Nr - 1 steg -1 ner till 1 InvShiftRows(stat) InvSubBytes(tillstånd) AddRoundKey(tillstånd, w[Nb * rund, Nb * (runda+1) - 1]) InvMixColumns(tillstånd) slut för InvShiftRows(stat) InvSubBytes(tillstånd) AddRoundKey(tillstånd, w[0, Nb - 1]) ut = tillstånd slutet

Pseudokod för invers chiffer

Algoritm för val av runda nyckel

Vid varje iteration väljs den runda nyckeln för AddRoundKey- operationen från arrayen , med början från element till .

Varianter av algoritmen

Baserat på Rijndael-algoritmen som ligger bakom AES, implementeras alternativa kryptoalgoritmer. Bland de mest kända är deltagarna i Nessie : Anubis- tävlingen om involutioner, författad av Vincent Rayman och en förbättrad version av chiffern - Grand Cru av Johan Borst.

Säkerhet

I juni 2003 fastställde USA :s nationella säkerhetsbyrå att AES var tillräckligt stark för att användas för att skydda sekretessbelagd information .  Upp till HEMLIG-nivån var det tillåtet att använda nycklar på 128 bitar, för TOP SECRET-nivån krävdes nycklar på 192 och 256 bitar [7] .

XSL-attack

Till skillnad från de flesta andra chiffer har AES en enkel matematisk beskrivning. Detta oroade bland annat Niels Ferguson , som i sitt arbete noterade att säkerheten för ett chiffer är baserat på ett nytt oprövat antagande om komplexiteten i att lösa vissa typer av ekvationer ( engelska  "The security of Rijndael beror på ett nytt och oprövat hårdhetsantagande : det är beräkningsmässigt omöjligt att lösa ekvationer av denna typ" ) [8] [9] , liksom Bruce Schneier, som skrev i en gemensam bok med Nils:

Vi har en kritik mot AES: vi litar inte riktigt på dess säkerhet. Det som oroar oss mest med AES är dess enkla algebraiska struktur... Inget annat blockchiffer har en så enkel algebraisk representation. Vi har ingen aning om detta leder till en attack eller inte, men att inte veta detta är skäl nog att vara skeptisk till att använda AES.

Originaltext  (engelska)[ visaDölj] Vi har en kritik mot AES: vi litar inte riktigt på säkerheten... Det som oroar oss mest med AES är dess enkla algebraiska struktur... Inget annat blockchiffer vi känner till har en så enkel algebraisk representation. Vi har ingen aning om detta leder till en attack eller inte, men att inte veta är skäl nog att vara skeptisk till användningen av AES - Niels Ferguson , Bruce Schneier Praktisk kryptografi - 2003 - pp. 56-57

Nicolas Courtois och Josef  Pieprzyk publiceradeen artikel 2002 där de beskrev en teoretisk attack som de kallade XSL- attacken ( eXtended Sparse Linearization ), som kunde tillåta att bryta AES-chiffer och Serpent [10] [11] . Men resultatet av arbetet accepterades inte optimistiskt av alla:   

Jag tror att det finns ett fel i Courtois-Pepshiks arbete. De överskattade antalet linjärt oberoende ekvationer. Som ett resultat har de inte tillräckligt med linjära ekvationer för att lösa systemet, och den [specificerade] metoden kan inte knäcka Rijndael. Det har vissa förtjänster och är värt att utforska, men det hackar inte Rijndael i sin nuvarande form.

Originaltext  (engelska)[ visaDölj] Jag anser att Courtois-Pieprzyks arbete är felaktigt. De överräknar antalet linjärt oberoende ekvationer. Resultatet är att de faktiskt inte har tillräckligt med linjära ekvationer för att lösa systemet, och metoden bryter inte Rijndael... Metoden har vissa fördelar och är värd att undersöka, men den bryter inte Rijndael som den ser ut. — Don Coppersmith , kommentar på blogginlägg av Bruce Schneier

På sidan tillägnad diskussionen om NESSIE- tävlingen , i slutet av 2002, uttalade en av författarna till chiffret, Vincent Rayman, att XSL-attacken bara är en dröm ( engelska  XSL-attacken är inte en attack. Det är en dröm ) (denna synpunkt upprepades senare 2004 vid den fjärde AES-konferensen i Bonn ). Till detta svarade Courtois att denna dröm skulle kunna bli en mardröm för författaren till AES ( engelska  It may also be a very bad dream and turn into a nightmare ) [12] (lek med ord: dröm översätts både som en dröm och som en dröm. dröm . Mardröm översätts som mardröm, mardröm ).

2003 publicerade Sean Murphy och Matt Robshaw ett  dokument där ( förutsatt att resultaten från Courtois och Pepshik är korrekta) motiverade möjligheten att attackera AES-algoritmen, vilket minskade antalet operationer för cracking från 2128 till 2100 . Men vid den 4:e AES-konferensen visade Ilia Toli och Alberto Zanoni att Murphy och Robshaws arbete var felaktigt [ 13] . Senare, 2007, visade Chu-Wee Lim och Khoongming Khoo också att denna attack inte kan fungera som beskrivits [14 ] .    

Sidokanalattack

Sidokanalattacker är inte relaterade till chifferets matematiska egenskaper, utan använder vissa implementeringsfunktioner i system som använder dessa chiffer för att avslöja delvis eller helt hemlig data, inklusive nyckeln. Det finns flera liknande attacker på system som använder AES-algoritmen.

I april 2005 publicerade Daniel J. Bernstein en  artikel som beskrev en attack som använder information om exekveringstiden för varje krypteringsoperation för att knäcka [15] . Denna attack krävde över 200 miljoner utvalda chiffertexter för att hitta nyckeln [16] .

I oktober 2005 presenterade Doug Arne Osvik, Adi Shamir och Eran Trumer ett dokument som beskrev flera attacker som använder tid för att hitta en nyckel. En av de presenterade attackerna fick nyckeln efter 800 krypteringsoperationer. Attacken krävde att kryptoanalytikern kunde köra program på samma system där krypteringen utfördes [17] .

I december 2009 publicerades ett dokument där användningen av differentiell felanalys ( eng.  Differential Fault Analysis ), artificiellt skapad i tillståndsmatrisen vid den 8:e omgången av kryptering, gjorde det möjligt att återställa nyckeln i 2 32 operationer [18 ] .

Se även

Anteckningar

  1. Chekanovs laboratorium. Intel Core i5 (Clarkdale): Analys av AES-krypteringshårdvaruacceleration . THG (19 januari 2010). - "den mest populära standarden för symmetrisk kryptering i IT-världen." Hämtad 14 november 2010. Arkiverad från originalet 26 februari 2012.
  2. Biryukov, Alex och Khovratovich, Dmitry. Related-key Cryptanalysis of the Full AES-192 and AES-256  (engelska)  // Advances in Cryptology - ASIACRYPT 2009. - Springer Berlin / Heidelberg, 2009. - Vol. 5912 . - S. 1-18 . - doi : 10.1007/978-3-642-10366-7_1 . Arkiverad från originalet den 18 december 2010.
  3. Arkiverad kopia (länk ej tillgänglig) . Hämtad 7 december 2006. Arkiverad från originalet 6 november 2006. 
  4. NIST-felsida arkiverad 28 september 2010.
  5. Bounce to index.html Arkiverad 17 juli 2014.
  6. http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf Arkiverad 7 april 2015 på Wayback Machine "5.1.3 MixColumns() Transformation .. Kolumnerna betraktas som polynom över GF( 2^8) och multiplicerat modulo x^4 + 1 med ett fast polynom a(x), givet av a(x) = {03}x³ + {01}x² + {01}x + {02}."
  7. ↑ Nationell policy för användningen av Advanced Encryption Standard (AES) för att skydda nationella säkerhetssystem och nationell säkerhetsinformation  . Kommittén för nationella säkerhetssystem (juni 2003). Datum för åtkomst: 27 oktober 2010. Arkiverad från originalet den 19 februari 2012.
  8. James McLaughlin. XSL-kontroversen // En undersökning av blockchifferkrypteringstekniker . — skriva ut. - York: University of York, 2009.  (otillgänglig länk)
  9. Niels Ferguson, Richard Schroeppel och Doug Whiting. En enkel algebraisk representation av Rijndael  //  Selected Areas in Cryptography, Proc. SAC 2001, föreläsningsanteckningar i datavetenskap #2259. - Springer Verlag, 2001. - S. 103-111 . Arkiverad från originalet den 16 januari 2016.
  10. Bruce Schneier. Crypto-Gram  nyhetsbrev . Schneier om säkerhet (15 september 2002). Datum för åtkomst: 27 oktober 2010. Arkiverad från originalet den 19 februari 2012.
  11. Nicolas Courtois, Josef Pieprzyk. Krypteringsanalys av blockchiffer med överdefinierade ekvationssystem  //  Framsteg inom kryptologi - ASIACRYPT 2002 8:e internationella konferensen om teoritillämpning av kryptologi och informationssäkerhet Queenstown, Nya Zeeland, 1-5 december 2002 Proceedings. Föreläsningsanteckningar i datavetenskap (2501). - Springer, 2002. - S. 267-287 . - doi : 10.1007/3-540-36178-2 . Arkiverad 26 oktober 2020.
  12. NESSIE diskussionsforum
  13. Ilia Toli, Alberto Zanoni. En algebraisk tolkning av AES-128   // Proc . från AES-konferensen. - 2005. - Vol. 2005 . - S. 84-97 . - doi : 10.1007/11506447_8 .  (inte tillgänglig länk)
  14. Chu-wee Lim, Khoongming Khoo. En analys av XSL tillämpad på BES  //  Snabb mjukvarukryptering. - Heidelberg: Springer Berlin / Heidelberg, 2007. - Vol. 4593 . - S. 242-253 . - doi : 10.1007/978-3-540-74619-5_16 .  (inte tillgänglig länk)
  15. Daniel J. Bernstein. Cache-timing attacker på  AES . - 2004. Arkiverad 17 september 2008.
  16. Bruce Schneier. AES Timing  Attack . Schneier om säkerhet (17 maj 2005). Datum för åtkomst: 27 oktober 2010. Arkiverad från originalet den 19 februari 2012.
  17. Dag Arne Osvik; Adi Shamir och Eran Tromer. Cache-attacker och motåtgärder: fallet med AES  // Ämnen i kryptologi - CT-RSA 2006, The Cryptographers' Track at the RSA Conference. - Springer-Verlag, 2005. - S. 1-20. Arkiverad 25 november 2020.
  18. Dhiman Saha, Debdeep Mukhopadhyay, Dipanwita Roy Chowdhury. En diagonal felattack på Advanced Encryption Standard   // Cryptology ePrint Archive . - 2009. Arkiverad den 6 augusti 2020.

Litteratur

Länkar