TE

TE
Skaber David Wheeler og Roger Needham
Oprettet 1994 _
offentliggjort 1994 _
Nøglestørrelse 128 bit
Blokstørrelse 64 bit
Antal runder 64 (32 cyklusser)
Type Feistel netværk

Inden for kryptografi er Tiny Encryption Algorithm (TEA) [1]  en blokkrypteringsalgoritme af typen Feistel Network . Algoritmen blev udviklet ved Computer Science Department ved University of Cambridge af David Wheeler ( David Wheeler ) og Roger Needham ( Roger Needham ) og blev første gang præsenteret i 1994 [2] ved et symposium om hurtige krypteringsalgoritmer i Leuven ( Belgien ).

Chifferen er ikke- proprietær , udbredt i en række kryptografiske applikationer og en bred vifte af hardware på grund af dets ekstremt lave hukommelseskrav og lette implementering. Algoritmen har både en softwareimplementering i forskellige programmeringssprog og en hardwareimplementering på FPGA -type integrerede kredsløb .

Egenskaber

TEA - krypteringsalgoritmen [1] er baseret på bitoperationer med en 64-bit blok, har en 128-bit krypteringsnøgle . Standardantallet af Feistel netværksrunder er 64 (32 runder ), men for at opnå den bedste ydeevne eller kryptering kan antallet af runder varieres fra 8 (16 runder) til 64 (128 runder). Feistel-netværket er asymmetrisk på grund af brugen af ​​modulo 2 32 addition som overlejringsoperation .

Fordelene ved chifferen er dens lette implementering, lille kodestørrelse og ret høje eksekveringshastighed samt muligheden for at optimere eksekveringen på standard 32-bit processorer, da hovedoperationerne er eksklusive "ELLER" (XOR) , bitvis skift og tilføjelse af modul 2 32 . Da algoritmen ikke bruger opslagstabeller, og rundfunktionen er ret enkel, skal algoritmen have mindst 16 cyklusser (32 runder) for at opnå effektiv diffusion, selvom fuld diffusion opnås i 6 cyklusser (12 runder). [en]

Algoritmen har fremragende modstand mod lineær kryptoanalyse og ret god modstand mod differentiel kryptoanalyse . Den største ulempe ved denne krypteringsalgoritme er dens sårbarhed over for relaterede nøgleangreb .  På grund af den enkle nøgleplanlægning har hver nøgle 3 tilsvarende nøgler. Det betyder, at den effektive nøglelængde kun er 126 bit [3] [4] , så denne algoritme bør ikke bruges som en hash-funktion .

Beskrivelse af algoritmen

Kildeteksten er opdelt i blokke på 64 bit hver. 128-bit nøglen K er opdelt i fire 32-bit undernøgler K[0], K[1], K[2] og K[3]. Dette fuldender den forberedende proces, hvorefter hver 64-bit blok krypteres i 32 cyklusser (64 runder) i henhold til nedenstående algoritme. [5]

Antag, at input fra den n. runde (for 1 ≤ n ≤ 64) er højre og venstre del (L n , R n ), så vil outputtet af n. runde være venstre og højre del (L n+1 , Rn +1 ), som beregnes efter følgende regler:

Ln +1 = Rn .

Hvis n = 2 * i - 1 for 1 ≤ i ≤ 32 (ulige runder), så er R n+1 = L n ({ [ R n 4 ] K[0] } { R n i * δ } { [ R n 5 ] K[1] })

Hvis n = 2 * i for 1 ≤ i ≤ 32 (lige runder), så er R n+1 = L n ({ [ R n 4 ] K[2] } { R n i * δ } { [ R n 5 ] K[3] })

Hvor

Det er også indlysende, at der ikke er nogen nøgleplanlægningsalgoritme som sådan i TEA-krypteringsalgoritmen. I stedet bruges undernøglerne K[0] og K[1] i ulige runder, og K[2] og K[3] i lige runder.

Da dette er en blokchiffer , hvor bloklængden er 64-bit, og datalængden muligvis ikke er et multiplum af 64-bit, er værdien af ​​alle bytes, der udfylder blokken til et multiplum af 64-bit, sat til 0x01.

Implementering

Implementeringen i programmeringssproget C (en tilpasset version af koden præsenteret i artiklen af ​​David Wheeler og Roger Needham [2] ) af krypterings- og dekrypteringsfunktionerne ved hjælp af TEA-algoritmen:

#include <stdint.h> ugyldig kryptering ( uint32_t * v , const uint32_t * k ) { /* Opsætning */ uint32_tv0 = v [ 0 ] ; uint32_tv1 = v [ 1 ] ; uint32_t sum = 0 ; uint32_t i ; /* en nøgleplanskonstant */ uint32_t delta = 0x9e3779b9 ; /* cache nøgle */ uint32_tk0 = k [ 0 ] ; uint32_tk1 = k [ 1 ] ; uint32_t k2 = k [ 2 ]; uint32_t k3 = k [ 3 ]; /* grundlæggende cyklus start */ for ( i = 0 ; i < 32 ; ++ i ) { sum += delta ; v0 += ( ( v1 << 4 ) + k0 ) ^ ( v1 + sum ) ^ ( ( v1 >> 5 ) + k1 ); v1 += ( ( v0 << 4 ) + k2 ) ^ ( v0 + sum ) ^ ( ( v0 >> 5 ) + k3 ); } /* slut cyklus */ v [ 0 ] = v0 ; v [ 1 ] = v1 ; } void dekrypter ( uint32_t * v , const uint32_t * k ) { /* Opsætning */ uint32_tv0 = v [ 0 ] ; uint32_tv1 = v [ 1 ] ; uint32_tsum = 0xC6EF3720 ; _ uint32_t i ; /* en nøgleplanskonstant */ uint32_t delta = 0x9e3779b9 ; /* cache nøgle */ uint32_tk0 = k [ 0 ] ; uint32_tk1 = k [ 1 ] ; uint32_t k2 = k [ 2 ]; uint32_t k3 = k [ 3 ]; /* grundlæggende cyklus start */ for ( i = 0 ; i < 32 ; ++ i ) { v1 -= ( ( v0 << 4 ) + k2 ) ^ ( v0 + sum ) ^ ( ( v0 >> 5 ) + k3 ); v0 -= ( ( v1 << 4 ) + k0 ) ^ ( v1 + sum ) ^ ( ( v1 >> 5 ) + k1 ); sum -= delta ; } /* slut cyklus */ v [ 0 ] = v0 ; v [ 1 ] = v1 ; }

Kommentarer:

  • v - kildetekst, bestående af to dele af 32 bit
  • k er en nøgle bestående af fire 32-bit dele

Ændringer fra original kode:

  • typen uint32_t bruges på grund af det faktum, at den altid er 32 bit i størrelse, i modsætning til long (til stede i den originale kode), som kan indeholde 64 bit (for eksempel på nogle 64-bit systemer)
  • kildekoden bruger ikke const-typen
  • redundante parenteser i udtrykkene for v0 og v1 er udeladt i kildekoden, i denne modifikation er de efterladt for større klarhed

Krypteringsanalyse

Det antages, at denne algoritme giver sikkerhed, der kan sammenlignes med IDEA- krypteringsalgoritmen , da den bruger den samme idé om at bruge operationer fra ortogonale algebraiske grupper . [1] Denne tilgang giver fremragende beskyttelse mod lineære kryptoanalyseteknikker .

Relaterede nøgleangreb

Algoritmen er mest sårbar over for relaterede -key- angreb på grund af den simple nøgleplanlægning ( inklusive manglen på en nøgleplanlægningsalgoritme som sådan). Der er mindst tre kendte angreb af denne type, de blev præsenteret i arbejde af John Kelsey ( John Kelsea ), Bruce Schneier ( Bruce Schneier ) og David Wagner ( David Wagner ) i 1997 [6] . Den simpleste af dem giver en differentialrespons med en sandsynlighed på 2 −32 efter 32 cyklusser af algoritmen, så der kræves mindst 2 34 valgte klartekster for at finde differentialresponsen med en sandsynlighed på 1 og bestemme alle bits af nøglen. Et mere komplekst angreb, som kombinerer ideerne fra Eli Bihams " linked key attack " [7] og et differentielt angreb , giver et differentielt svar med en sandsynlighed på 2 −11 , kræver kun 2 23 valgte klartekster og en tid på ca. 2 32 krypteringstider (det vil sige, det kræver antallet af bitoperationer i størrelsesordenen 2 32 ).  

Differentiel kryptoanalyse

TEA har vist sig at være ret robust over for differentiel kryptoanalyse . Et 10-runders TEA-angreb kræver 2 52,5 valgte klartekster og har en tidskompleksitet på 2 84 [8] . Det bedste resultat er kryptoanalyse af 17 runder TEA [9] . Dette angreb kræver kun 1920 valgte klartekster, men har en tidskompleksitet på 2123,37 .

Tilsvarende nøgler

Et andet problem med TEA-algoritmen er eksistensen af ​​tilsvarende nøgler. Det har vist sig, at hver nøgle har tre ækvivalenter [4] . Dette betyder, at den effektive nøglelængde kun er 126 bits i stedet for de 128, som udviklerne har tiltænkt, så TEA er ikke ønskeligt at bruge som en hash-funktion , hvilket blev afspejlet i Andrew Huangs bog " Hacking the Xbox: an introduction to reverse engineering" ("Hacking the Xbox: An Introduction to Reverse Engineering") ved at bruge eksemplet med at hacke Microsoft Xbox -spillekonsollen .

Tabel over tilsvarende nøgler:

K[0] K[1] K[2] K[3]
K[0] K[1] K[2] 80000000 timer K[3] 80000000 timer
K[0 ] 80000000h K[1] 80000000 t K[2] K[3]
K[0 ] 80000000h K[1] 80000000 t K[2] 80000000 timer K[3] 80000000 timer

Algoritmeudvidelser

Opdagelsen af ​​en række alvorlige sårbarheder og svagheder i den originale TEA-algoritme førte til den hurtige oprettelse af dens udvidelser. De vigtigste forskelle ved alle disse algoritmer er et forbedret nøgleskema, nøglens dynamiske afhængighed af teksten, samt en anden nøglestørrelse, inputblok og/eller antallet af runder af Feistel-netværket.

XTEA

XTEA har en blokstørrelse på 64 bit, en nøglestørrelse på 128 bit og en Feistel netværksrunde på 64. Algoritmen blev udviklet af David Wheeler og Roger Needham og udgivet i 1997 . Den største forskel fra den originale TEA-algoritme er tilstedeværelsen af ​​en nøgleplanlægningsalgoritme, som gjorde det muligt at eliminere en kritisk sårbarhed for "angreb på relaterede nøgler", men førte til en forringelse af modstanden mod differentiel kryptoanalyse [9] . Der er tre modifikationer af denne algoritme udviklet af Tom Denis [10] : XTEA-1 (blokstørrelse - 64 bit, nøglestørrelse - 128 bit, antal Feistel netværksrunder - 32), XTEA-2 (blokstørrelse - 128 bit , nøglestørrelse 128 bit, antal Feistel netværksrunder 64) og XTEA-3 (blokstørrelse 128 bit, nøglestørrelse 256 bit, antal Feistel netværksrunder 64).

XXTEA

I 1998 blev den næste udvidelse af algoritmen offentliggjort, kaldet XXTEA . Nøglens størrelse er 128 bit. Et karakteristisk træk er evnen til at kryptere alle blokke, der er et multiplum af 64 bit, antallet af runder er 52 + 6 * (antallet af 32-bit ord i en blok) eller 52 + 12 * M med en bloklængde på 64 * M bit. Den praktiske effektivitet af et anonymt offentliggjort differentielt angreb er ikke blevet bevist [11] .

RTEA

Der er også en alternativ modifikation af TEA-algoritmen, kaldet RTEA , udviklet i 2007 af Marcos el Ruptor . Blokstørrelse - 64 bit; for en 128-bit nøgle er antallet af runder af Feistel-netværket 48, for en 256-bit nøgle er det 64. Ifølge udviklerne er denne algoritme dog mere produktiv og mere modstandsdygtig over for kryptoanalyse [12] end XTEA , har denne algoritme allerede et "angreb på relaterede nøgler" [13] .

Raiden

Ved at bruge genetiske programmeringsmekanismer i 2006 skabte et team af udviklere ledet af Julio Castro ( eng.  Julio César Hernández Castro ) Raiden - algoritmen , designet til at eliminere sårbarhederne i TEA-chifferet. Den gentager næsten nøjagtigt strukturen af ​​TEA-algoritmen, bortset fra at Raiden- algoritmen har en udvidet nøgleplanlægningsalgoritme. Standardantallet af runder af Feistel-netværket er 32 (16 cykler). Raiden bruger et PRNG-lignende nøgleskema, transformerer nøglen og genererer undernøgler for hver runde. Chifferen består succesfuldt Diehard , Sexton og ØNH -testene [14] .

Sammenligning af forskellige versioner af TEA-algoritmeudvidelsen

Her er en sammenlignende tabel over de vigtigste egenskaber ved TEA-familien af ​​algoritmer:

Algoritme navn Standard antal Feistel netværksrunder Blokstørrelse Nøglestørrelse
TE 64 64 bit 128 bit
XTEA 64 64 bit 128 bit
XTEA-1 32 64 bit 128 bit
XTEA-2 64 128 bit 128 bit
XTEA-3 64 128 bit 256 bit
XXTEA 52+12*M 64*M bit 128 bit
RTEA 48 eller 64 64 bit 128 eller 256 bit
Raiden 32 64 bit 128 bit

Samtidig gør forfatterne af TEA-algoritmen på deres officielle side [1] opmærksom på det faktum, at TEA-algoritmen under reelle praktiske forhold stadig er ret pålidelig, og at alle de fundne sårbarheder som regel ikke er kritisk, for eksempel ved overførsel af data i realtid.

Se også

Noter

  1. 1 2 3 4 5 TEA-krypteringsside (linket er ikke tilgængeligt) . Hentet 25. februar 2009. Arkiveret fra originalen 12. juni 2017. 
  2. 1 2 3 Roger M. Needham og David J. Wheeler. TEA, en lille krypteringsalgoritme arkiveret 13. oktober 2017 på Wayback Machine
  3. Kelsey, John; Schneier, Bruce; Wagner, David. Nøgleskema-krypteringsanalyse af IDEA, G-DES, GOST, SAFER og Triple-DES  (engelsk)  // Lecture Notes in Computer Science: journal. - 1996. - Bd. 1109 . - S. 237-251 . - doi : 10.1007/3-540-68697-5_19 .
  4. 1 2 Andem, Vikram Reddy (2003). En kryptoanalyse af den lille krypteringsalgoritme Arkiveret fra originalen den 20. april 2009.
  5. Seokhie Hong, Deukjo Hong, Youngdai Ko, Donghoon Chang, Wonil Lee, Sangjin Lee, (2003). Differentiel krypteringsanalyse af TEA og XTEA  (utilgængeligt link)
  6. Kelsey, John; Schneier, Bruce; Wagner, David. Relateret nøglekrypteringsanalyse af 3-WAY, Biham-DES, CAST, DES-X NewDES, RC2 og TEA  //  Lecture Notes in Computer Science: journal. - 1997. - Bd. 1334 . - S. 233-246 . - doi : 10.1007/BFb0028479 .
  7. Eli Biham, Computer Science Department, Technion - Israel Institute of Technology, Haifa 32000, Israel, (1992). "Nye typer af kryptoanalytiske angreb ved hjælp af relaterede nøgler"  (utilgængeligt link)
  8. Måne, Dukjae; Hwang, Kyungdeok; Lee, Wonil; Lee, Sangjin; Lim, Jongin. Umulig differentiel kryptoanalyse af reduceret rund XTEA og TEA  //  Lecture Notes in Computer Science: journal. - 2002. - Bd. 2365 . - S. 49-60 . - doi : 10.1007/3-540-45661-9_4 .
  9. 1 2 Hong, Seokhie; Hong, Deukjo; Ko, Youngdai; Chang, Donghoon; Lee, Wonil; Lee, Sangjin. Differentiel kryptoanalyse af TEA og XTEA  (udefineret)  // In Proceedings of ICISC 2003. - 2003.  (utilgængeligt link)
  10. Tom St Denis. Udvidede TEA Algorithms Arkiveret 27. august 2018 på Wayback Machine
  11. Originalartikel med implementeringen af ​​angrebet på XXTEA og prøvekode (downlink) . Hentet 6. november 2009. Arkiveret fra originalen 23. september 2009. 
  12. Sammenlignende resultater af stabilitet af symmetriske kryptoalgoritmer Arkiveret den 25. juli 2008.  (Engelsk)
  13. Et relateret nøgleangreb for RTEA.  (utilgængeligt link)
  14. [ Raiden: Et alternativ til TEA Block Cipher  ] . Hentet 6. november 2009. Arkiveret fra originalen 5. marts 2016. Raiden: Et alternativ til TEA Block Cipher 

Links