public class TEA
extends java.lang.Object
(The following description is from the web page for the C and Assembler source code at University of Bradford Yorkshire, England - The Cryptography & Computer Communications Security Group) The description is used with the permission of the authors, Dr S J Shepherd and D A G Gillies.
The Tiny Encryption Algorithm is one of the fastest and most efficient cryptographic algorithms in existence. It was developed by David Wheeler and Roger Needham at the Computer Laboratory of Cambridge University. It is a Feistel cipher which uses operations from mixed (orthogonal) algebraic groups - XORs and additions in this case. It encrypts 64 data bits at a time using a 128-bit key. It seems highly resistant to differential cryptanalysis, and achieves complete diffusion (where a one bit difference in the plaintext will cause approximately 32 bit differences in the ciphertext) after only six rounds. Performance on a modern desktop computer or workstation is very impressive.
TEA takes 64 bits of data in v[0] and v[1], and 128 bits of key in k[0] - k[3]. The result is returned in w[0] and w[1]. Returning the result separately makes implementation of cipher modes other than Electronic Code Book a little bit easier.
TEA can be operated in any of the modes of DES.
n is the number of iterations. 32 is ample, 16 is sufficient, as few as eight should be OK for most applications, especially ones where the data age quickly (real-time video, for example). The algorithm achieves good dispersion after six iterations. The iteration count can be made variable if required.
Note this algorithm is optimised for 32-bit CPUs with fast shift capabilities. It can very easily be ported to assembly language on most CPUs.
delta is chosen to be the Golden ratio ((5/4)1/2 - 1/2 ~ 0.618034) multiplied by 232. On entry to decipher(), sum is set to be delta * n. Which way round you call the functions is arbitrary: DK(EK(P)) = EK(DK(P)) where EK and DK are encryption and decryption under key K respectively.
Translator's notes:
Tiny Encryption Algorithm (TEA)
TEA is a cryptographic algorithm designed to minimize memory
footprint, and maximize speed. However, the cryptographers from Counterpane Systems have discovered three related-key
attacks on TEA, the best of which requires only 223 chosen plaintexts and one related
key query. The problems arise from the overly simple key schedule. Each TEA key can be
found to have three other equivalent keys, as described in a paper by David Wagner, John Kelsey, and Bruce Schneier. This precludes the
possibility of using TEA as a hash function. Roger Needham and David Wheeler have proposed
extensions to TEA that
counters the above attacks.
Example of use:
byte key[] = new BigInteger("39e858f86df9b909a8c87cb8d9ad599", 16).toByteArray(); TEA t = new TEA(key);
String src = "hello world!"; System.out.println("input = " + src); byte plainSource[] = src.getBytes(); int enc[] = t.encode(plainSource, plainSource.length); System.out.println(t.padding() + " bytes added as padding."); byte dec[] = t.decode(enc); System.out.println("output = " + new String(dec));
Constructor and Description |
---|
TEA(byte[] key)
Accepts key for enciphering/deciphering.
|
Modifier and Type | Method and Description |
---|---|
byte[] |
decipher(byte[] v)
Decipher two
bytes s. |
int[] |
decipher(int[] v)
Decipher two
int s. |
byte[] |
decode(byte[] b,
int count)
Convert a byte array to ints and then decode.
|
byte[] |
decode(int[] b)
Decode an integer array.
|
byte[] |
encipher(byte[] v)
Encipher two
bytes s. |
int[] |
encipher(int[] v)
Encipher two
int s. |
int[] |
encode(byte[] b,
int count)
Byte wrapper for encoding.
|
static void |
main(java.lang.String[] args)
Encodes and decodes "Hello world!"
|
int |
padding()
Report how much padding was done in the last encode.
|
java.lang.String |
toString()
Representation of TEA class
|
public TEA(byte[] key)
key
- 128 bit (16 byte) key.java.lang.ArrayIndexOutOfBoundsException
- if the key isn't the correct length.public static void main(java.lang.String[] args)
public java.lang.String toString()
toString
in class java.lang.Object
public int[] encipher(int[] v)
int
s.
Replaces the original contents of the parameters with the results.
The integers are usually created from 8 bytes.
The usual way to collect bytes to the int array is:
byte ba[] = { .... }; int v[] = new int[2]; v[0] = (ba[j] << 24 ) | (((ba[j+1])&0xff) << 16) | (((ba[j+2])&0xff) << 8) | ((ba[j+3])&0xff); v[1] = (ba[j+4] << 24 ) | (((ba[j+5])&0xff) << 16) | (((ba[j+6])&0xff) << 8) | ((ba[j+7])&0xff); v = encipher(v);
v
- two int
array as input.int
s, enciphered.public int[] decipher(int[] v)
int
s.
Replaces the original contents of the parameters with the results.
The integers are usually decocted to 8 bytes.
The decoction of the int
s to bytes can be done
this way.
int x[] = decipher(ins); outb[j] = (byte)(x[0] >>> 24); outb[j+1] = (byte)(x[0] >>> 16); outb[j+2] = (byte)(x[0] >>> 8); outb[j+3] = (byte)(x[0]); outb[j+4] = (byte)(x[1] >>> 24); outb[j+5] = (byte)(x[1] >>> 16); outb[j+6] = (byte)(x[1] >>> 8); outb[j+7] = (byte)(x[1]);
v
- int
array of 2int
array of 2public byte[] encipher(byte[] v)
bytes
s.v
- byte
array of 2byte
array of 2public byte[] decipher(byte[] v)
bytes
s.v
- byte
array of 2byte
array of 2public int[] encode(byte[] b, int count)
b
- incoming byte
arraybyte
- countpadding()
public int padding()
encode(byte[], int)
public byte[] decode(byte[] b, int count)
b
- bytes to decodecount
- number of bytes in the array to decodebyte
array of decoded bytes.public byte[] decode(int[] b)
b
- bytes to decodecount
- number of bytes in the array to decodebyte
array of decoded bytes.