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.
| 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. | |
Eigenschaften
BearbeitenXTEA 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 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.[1] 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.[2]
Referenzcode
BearbeitenEs 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 longstatt der 64-bit-tauglichenuint32_tTypen. - Der Originalcode verwendete keine
constTypen. - Der Originalcode vermeidet redundante Klammerungen, was die Lesbarkeit des Codes reduziert.
XXTEA
BearbeitenXXTEA oder Extended XTEA ist eine 1998 ebenfalls von Wheeler und Needham vorgestellte verbesserte Version von XTEA.[3] Die Blockgröße ist variabel, ein Block besteht aus zwei oder mehr 32-Bit-Wörtern, und die Rundenzahl richtet sich nach der Blockgröße.
Referenzimplementierung
BearbeitenDavid Wheeler und Roger Needham veröffentlichten folgenden Referenzcode für XXTEA:[3]
#include <stdint.h>
#define DELTA 0x9e3779b9
#define MX (((z>>5^y<<2) + (y>>3^z<<4)) ^ ((sum^y) + (key[(p&3)^e] ^ z)))
void btea(uint32_t *v, int n, uint32_t const key[4]) {
uint32_t y, z, sum;
unsigned p, rounds, e;
if (n > 1) { /* Coding Part */
rounds = 6 + 52/n;
sum = 0;
z = v[n-1];
do {
sum += DELTA;
e = (sum >> 2) & 3;
for (p=0; p<n-1; p++) {
y = v[p+1];
z = v[p] += MX;
}
y = v[0];
z = v[n-1] += MX;
} while (--rounds);
} else if (n < -1) { /* Decoding Part */
n = -n;
rounds = 6 + 52/n;
sum = rounds*DELTA;
y = v[0];
do {
e = (sum >> 2) & 3;
for (p=n-1; p>0; p--) {
z = v[p-1];
y = v[p] -= MX;
}
z = v[n-1];
y = v[0] -= MX;
sum -= DELTA;
} while (--rounds);
}
}
Sicherheit
Bearbeiten2010 veröffentlichte Elias Yarrkov einen Chosen Plaintext Angriff, der auf Differenzieller Kryptoanalyse beruht und mit 259 Versuchen erfolgreich ist.[4]
Anwendungen
BearbeitenXXTEA wird beispielsweise eingesetzt im Funkprotokoll des Kollisionswarngerätes FLARM sowie im ADS-L Standard.[5] Eine wissenschaftliche Studie der ETH Zürich kam zu dem Ergebnis, dass es aus Sicht der Informationssicherheit keinen offensichtlichen Grund mehr für die Verschlüsselung gebe und FLARM nicht sicherer sei als andere bestehende Luftfahrtprotokolle, die von Anfang an ohne kryptographische Sicherheitsmaßnahmen entwickelt wurden.[6] Analog gilt diese Schlussfolgerung auch für ADS-L.
Weblinks
BearbeitenEinzelnachweise
Bearbeiten- ↑ Jiqiang Lu: Related-key rectangle attack on 36 rounds of the XTEA block cipher In: International Journal of Information Security, February 2009, S. 1–11, Springer-Verlag.
- ↑ Andrey Bogdanov und Meiqin Wang: Zero correlation linear cryptanalysis with reduced data complexity. In: Proceedings of FSE 2012, S. 29–48, Springer-Verlag.
- ↑ a b David J. Wheeler, Roger M. Needham: Correction to XTEA. Computer Laboratory, Cambridge University, 1998, abgerufen am 25. März 2024 (englisch).
- ↑ Elias Yarrkov: Cryptanalysis of XXTEA. In: Cryptology ePrint Archive. 2010, abgerufen am 26. März 2024 (englisch).
- ↑ EASA: Technical Specification for ADS-L transmissions using SRD-860 frequency band (ADS-L 4 SRD-860). EASA, 20. Dezember 2022, abgerufen am 25. März 2024 (englisch).
- ↑ Boya Wang, Giorgio Tresoldi, Martin Strohmeier, Vincent Lenders: On the Security of the FLARM Collision Warning System. In: Proceedings of the 2022 ACM on Asia Conference on Computer and Communications Security (= ASIA CCS '22). Association for Computing Machinery, New York, NY, USA 2022, ISBN 978-1-4503-9140-5, S. 267–278, doi:10.1145/3488932.3517409.