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 $\lfloor ({\sqrt {5}}-1)\cdot 2^{31}\rfloor$ 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.

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

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