Cet article est une ébauche concernant la cryptologie.

Vous pouvez partager vos connaissances en l’améliorant (comment ?) selon les recommandations des projets correspondants.

En cryptographie, XTEA (eXtended TEA) est un algorithme de chiffrement conçu pour corriger les faiblesses de TEA. David Wheeler et Roger Needham, de l'université de Cambridge, ont conçu cet algorithme qui fut proposé dans un rapport technique non publié en 1997 (Needham and Wheeler, 1997). Il n'est soumis à aucun brevet.

Tout comme TEA, XTEA est basé sur un réseau de Feistel de blocs de 64 bits, avec une clé de 128 bits en 64 tours recommandés. Plusieurs différences sont notables vis-à-vis de TEA, notamment un plan de génération de clés plus élaboré et un arrangement des décalages, XOR et additions.

Parallèlement à XTEA, un algorithme de chiffrement par blocs de tailles variables, dénommé Block TEA, est présenté dans le même rapport ; il utilise la fonction par tour de XTEA mais s'applique cycliquement à tout le message lors de plusieurs itérations. Vu qu'il traite l'ensemble du message, Block TEA a la particularité de n'avoir pas besoin d'un mode d'opération. Une attaque sur cet algorithme est décrite par Markku-Juhani Saarinen dans un rapport de 1998 non publié ; il a aussi découvert une faiblesse dans XXTEA, le successeur de Block TEA.

Jusqu'en 2004, la meilleure attaque sur XTEA est une cryptanalyse différentielle par clé apparentée sur 24 des 64 tours de XTEA, demandant 2^20.5 textes choisis et une complexité de 2^115.15 (Ko et al, 2004).

Implémentations

Ce code source standard en langage C — mis dans le domaine public par David Wheeler et Roger Needham — procède au chiffrement et au déchiffrement en utilisant XTEA :

void encipher(unsigned int num_rounds, unsigned long* v, unsigned long* k) {
    unsigned long v0=v[0], v1=v[1], i;
    unsigned long sum=0, delta=0x9E3779B9;
    for(i=0; i<num_rounds; i++) {
        v0 += ((v1 << 4 ^ v1 >> 5) + v1) ^ (sum + k[sum & 3]);
        sum += delta;
        v1 += ((v0 << 4 ^ v0 >> 5) + v0) ^ (sum + k[sum>>11 & 3]);
    }
    v[0]=v0; v[1]=v1;
}

void decipher(unsigned int num_rounds, unsigned long* v, unsigned long* k) {
    unsigned long v0=v[0], v1=v[1], i;
    unsigned long delta=0x9E3779B9, sum=delta*num_rounds;
    for(i=0; i<num_rounds; i++) {
        v1 -= ((v0 << 4 ^ v0 >> 5) + v0) ^ (sum + k[sum>>11 & 3]);
        sum -= delta;
        v0 -= ((v1 << 4 ^ v1 >> 5) + v1) ^ (sum + k[sum & 3]);
    }
    v[0]=v0; v[1]=v1;
}

Le code-source original possède des défauts de portabilité vers les plateformes non-32 bits. Le code suivant est une adaptation portable du code-source original, car explicitant les types d'entiers qu'elle utilise:

#include <stdint.h>

/* Prend 64 bits de données de v[0] et v[1], et 128 bits de key[0] à key[3] */

void encipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) {
    unsigned int i;
    uint32_t v0=v[0], v1=v[1], sum=0, delta=0x9E3779B9;
    for (i=0; i < num_rounds; i++) {
        v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
        sum += delta;
        v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3]);
    }
    v[0]=v0; v[1]=v1;
}

void decipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) {
    unsigned int i;
    uint32_t v0=v[0], v1=v[1], delta=0x9E3779B9, sum=delta*num_rounds;
    for (i=0; i < num_rounds; i++) {
        v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3]);
        sum -= delta;
        v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
    }
    v[0]=v0; v[1]=v1;
}

Les modifications depuis le code source de référence sont mineures:

• Le code source de référence utilisait le type unsigned long plutôt que le type uint32_t, lequel permet d'expliciter le type sur les plateformes 64-bits.
• Le code source de référence n'utilisait pas de types constants (mot-clé const)
• Le code source de référence omettait certaines parenthèses répétitives, exploitant la priorité d'exécution du C pour effectuer un arrondi sans recourir à une fonction appropriée (exemple: v1 +=

(v0<<4 ^ v0>>5) + v0 ^ sum + k[sum>>11 & 3];)

Références