Extended Tiny Encryption Algorithm

XTEA
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
Mit Stand vom Jahr 2004 ist der beste bekannte Angriff auf eine reduzierte Anzahl von 26 Feistelrunden bekannt.

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

Eigenschaften

XTEA arbeitet auf 64-bit großen Blöcken und benutzt einen 128-bit langen Schlüssel. Er stellt eine Feistelchiffre mit einer vorgeschlagenen Feistel-Rundenanzahl von 64 dar. Normalerweise ist er so implementiert, dass 2 Runden einen Zyklus darstellen. Er hat einen sehr einfachen Mechanismus zur Erzeugung des jeweiligen Rundenschlüssels. Das Einbringen eines sogenannten Deltas, das wie bei TEA als $({\sqrt {5}}-1)\cdot 2^{31}$ definiert ist, verhindert einen Angriff, der auf der Symmetrie der einzelnen Runden basiert. Allerdings wird bei XTEA das Delta anders in die Runde eingebracht, was die eigentliche Stärkung des Algorithmus bewirkt.

Mit Stand vom Jahr 2004 ist der beste bekannte Angriff in Form der verwandten Schlüssel-Attacke (engl. related-key attack) auf XTEA in einer bewusst schwächer gewählten Implementierung von nur 26 Runden (empfohlen sind 64) bekannt. Dieser Angriff benötigt mindestens 2^20,5 frei gewählte Klartextblöcke.

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>

/* take 64 bits of data in v[0] and v[1] and 128 bits of key in k[0] - k[3] */

void encipher(unsigned int num_rounds, uint32_t v[2], uint32_t const k[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 + 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, uint32_t v[2], uint32_t const k[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 + 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:

• Der 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

• Seite mit verschiedenen TEA and XTEA Implementierungen (engl.)
• PHP Implementierung von XTEA
• Testvektoren für TEA und XTEA (engl.)