Tiny Encryption Algorithm

Tiny Encryption Algorithm
	Due passaggi della funzione Feistel (1 ciclo) nel TEA
Generale
Progettisti	Roger Needham, David Wheeler
Prima pubblicazione	1994
Successori	XTEA, XXTEA
Dettagli
Dimensione chiave	128 bits
Dimensione blocco	64 bits
Struttura	Rete di Feistel
Numero di passaggi	variabili: raccomandanti 64 passaggi della funzione Feistel (32 cicli)
Migliore crittanalisi
	Il TEA soffre del problema delle chiavi equivalenti (Kelsey ed altri autori, 1996) e può essere violato utilizzando un attacco correlato alla chiave utilizzando 223 testi in chiaro scelti ed un tempo di 232.

In crittografia il Tiny Encryption Algorithm (TEA) è un cifrario a blocchi noto per la sua semplicità e facilità di implementazione (bastano in genere poche linee di codice). Fu ideato da David Wheeler e Roger Needham del dipartimento informatico dell'Università di Cambridge^[1], e presentato per la prima volta nel 1994 al secondo Fast Software Encryption, tenutosi a Lovanio (Belgio)^[2].

L'algoritmo non è soggetto ad alcun brevetto.

Proprietà modifica

Il TEA opera su blocchi di 64 bit ed utilizza una chiave crittografica lunga 128 bit. Ha una struttura a rete di Feistel con 64 passaggi (suggeriti), in genere implementati a coppie denominate cicli. Ha una funzione di gestione della chiave molto semplice, che ne mescola tutti i bit nella stessa maniera ad ogni ciclo. Vengono inoltre utilizzati i multipli di una costante per rendere l'algoritmo resistente agli attacchi più semplici basati sulla simmetria dei passaggi. Questa costante, 2654435769 ( $\mathrm {9E3779B9_{16}}$ ) è scelta per essere $\lfloor 2^{32}/\phi \rfloor$ dove $\phi$ è la sezione aurea.

Il TEA ha alcune debolezze la più grave delle quali è legata alle chiavi equivalenti: ogni chiave è equivalente ad altre 3, il che significa che la lunghezza effettiva della chiave risulta essere di soli 126 bit^[3]. Come conseguenza di ciò, il TEA non è assolutamente indicato come funzione crittografica di hash. Questa debolezza è stata usata per hackerare la console Microsoft Xbox, dove il cifrario era utilizzato come funzione di hash per il controllo del software di avvio^[4]. Il TEA è anche suscettibile di un attacco correlato alla chiave, che richiede 2²³ testi in chiaro scelti con una coppia di chiavi correlate ed un tempo di 2³²^[5].

L'inusuale minima dimensione del TEA lo renderebbe un'interessante scelta in molte situazioni dove si hanno vincoli estremi legati alle risorse, ad esempio nei vecchi sistemi hardware dove la quantità di memoria è spesso minima. D'altronde, la comprovata insicurezza dell'algoritmo suggerisce di utilizzare una delle varianti che sono state presentate per correggere le debolezze della sua struttura.

Versioni modifica

La prima versione pubblica del TEA fu seguita da una seconda versione denominata XTEA, eXtended TEA, che incorporava alcune modifiche atte a rendere l'algoritmo più sicuro: a differenza dell'algoritmo originale, essa integra una funzione di gestione della chiave più complessa ed una diversa successione delle operazioni di spostamento dei bit (shift), XOR ed addizione. Insieme all'XTEA fu presentato anche il Block TEA, identico all'XTEA ma che itera sull'intero messaggio considerandolo un unico blocco.

Una terza versione, denominata Corrected Block TEA (noto come XXTEA), fu pubblicata nel 1998: deriva dall'XTEA ma si differenzia per la possibilità di utilizzare blocchi di dati di qualunque lunghezza.

Codice di riferimento modifica

Quelle che seguono sono adattamenti in C delle routine di cifratura e decifratura del TEA, rilasciate nel pubblico dominio da David Wheeler e Roger Needham:

#include <stdint.h>

void encrypt (uint32_t* v, uint32_t* k) {
    uint32_t v0=v[0], v1=v[1], sum=0, i;           /* set up */
    uint32_t delta=0x9e3779b9;                     /* a key schedule constant */
    uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3];   /* cache key */
    for (i=0; i < 32; i++) {                       /* basic cycle start */
        sum += delta;
        v0 += ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
        v1 += ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);  
    }                                              /* end cycle */
    v[0]=v0; v[1]=v1;
}

void decrypt (uint32_t* v, uint32_t* k) {
    uint32_t v0=v[0], v1=v[1], sum=0xC6EF3720, i;  /* set up ;sum == delta*32 */
    uint32_t delta=0x9e3779b9;                     /* a key schedule constant */
    uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3];   /* cache key */
    for (i=0; i<32; i++) {                         /* basic cycle start */
        v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
        v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
        sum -= delta;                                   
    }                                              /* end cycle */
    v[0]=v0; v[1]=v1;
}

Da notare che l'implementazione standard è legata ad una specifica architettura di microprocessori, il che significa che le considerazioni sull'ordine dei byte sono importanti quando il testo cifrato è distribuito e processato su diversi sistemi. Il documento originale non specifica nessun dettaglio sull'architettura dei microprocessori perciò chiunque implementi un sistema che utilizza il TEA è tenuto a considerare in proprio quelle specifiche.

Note modifica

Voci correlate modifica

RC4 - Un cifrario a flusso che, come il TEA, è progettato per essere molto semplice da implementare.
XTEA - Il Block TEA, la prima versione modificata del TEA.
XXTEA - Il Corrected Block TEA, la seconda versione modificata del TEA.