Extended Tiny Encryption Algorithm

XTEA
Zwei Feistel-Runden (ein Zyklus) von XTEA
Entwickler	Roger Needham, David Wheeler
Veröffentlicht	1997
Abgeleitet von	TEA
Schlüssellänge	128 Bit
Blockgröße	64 Bit
Struktur	Feistelchiffre
Runden	variabel, 64 Feistelrunden (32 Zyklen) empfohlen
Beste bekannte Kryptoanalyse
Stand 2009 können bis zu 36 Feistelrunden erfolgreich angegriffen werden.

Der XTEA (eXtended Tiny Encryption Algorithm) ist eine Blockchiffre, die als Verbesserung der Blockchiffre TEA entwickelt wurde. XTEA ist wie TEA bekannt für ihre einfache Beschreibung und Implementierung. Der Code als C-Programm umfasst nur einige Zeilen. XTEA wurde von David Wheeler und Roger Needham an der Universität Cambridge im Jahr 1997 entwickelt. XTEA ist wie auch sein Vorgänger TEA frei von Patenten.

Eigenschaften

XTEA ist eine Feistelchiffre mit 64 Bit großen Datenblöcken und einem 128 Bit langen Schlüssel. In der Regel werden 64 Runden = 32 Zyklen berechnet (empfohlener Wert, kann auch geändert werden). Der Mechanismus zur Erzeugung der Rundenschlüssel ist sehr einfach gehalten. Das Einbringen eines sogenannten Deltas, das wie bei TEA als $\lfloor ({\sqrt {5}}-1)\cdot 2^{31}\rfloor$ definiert ist, verhindert einen Angriff, der die Symmetrie der einzelnen Runden ausnutzt. Allerdings wird bei XTEA das Delta anders in die Runde eingebracht, was hauptsächlich die Stärkung der Verschlüsselung bewirkt.

2009 präsentierte Jiqiang Lu einen Related-key rectangle attack auf 36 Runden. Dieser Angriff betrifft bis zum Stand 2015 die höchste Rundenanzahl. Andrey Bogdanov und Meiqin Wang stellten 2012 außerdem eine Zero correlation linear cryptanalysis auf 27 Runden XTEA vor.

Referenzcode

Es folgt die Adaptierung der Referenzimplementierung der Ver- und Entschlüsselungsroutinen in C, die als Public Domain von David Wheeler und Roger Needham veröffentlicht wurde:

#include <stdint.h>

/* gegeben sind 64 Datenbits in v[0] und v[1] und 128 Schlüsselbits in k[0] bis k[3] */
/* Die Daten werden mit 2 * num_cycles Runden verschlüsselt */

void encipher (unsigned int num_cycles, uint32_t v[2], uint32_t const k[4]) {
    unsigned int i;
    const uint32_t delta = 0x9E3779B9;
    uint32_t v0 = v[0], v1 = v[1], sum = 0;
    for (i=0; i < num_cycles; 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_cycles, uint32_t v[2], uint32_t const k[4]) {
    unsigned int i;
    const uint32_t delta = 0x9E3779B9;
    uint32_t v0 = v[0], v1 = v[1], sum = delta * num_cycles;
    for (i=0; i < num_cycles; 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;
}

Die Adaptierung zur Originalimplementierung betreffend kleinere Randpunkte:

• Die Originalimplementierung verwendet die Typen unsigned long statt der 64-bit-tauglichen uint32_t Typen.
• Der Originalcode verwendete keine const Typen.
• Der Originalcode vermeidet redundante Klammerungen, was die Lesbarkeit des Codes reduziert.

Weblinks

• verschiedene TEA- und XTEA-Implementierungen (Archivlink, englisch)
• PHP Implementierung von XTEA
• Testvektoren für TEA und XTEA (englisch)