superwaba.ext.xplat.util.crypto
Class TEA

java.lang.Object
  |
  +--superwaba.ext.xplat.util.crypto.TEA

public class TEA
extends Object

Tiny Encryption Algorithm.

Important! You have to init TEA with a byte array with a length of a multiple of 16. If the length doesn't match a multiple of 16 the initialization would fail.

(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:

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));

Since:
JDK1.1

Constructor Summary
TEA(byte[] key)
          Accepts key for enciphering/deciphering.
TEA(int[] key)
           
 
Method Summary
 String binToHex(int[] enc)
          Convert an array of ints into a hex string.
 int[] decipher(int[] v)
          Decipher two ints.
 byte[] decode(byte[] b, int count)
          Convert a byte array to ints and then decode.
 byte[] decode(int[] b)
          Decode an integer array.
 int[] encipher(int[] v)
          Encipher two ints.
 int[] encode(byte[] b, int count)
          Byte wrapper for encoding.
 String getHex(byte[] b)
          Display bytes in HEX.
 int padding()
          Report how much padding was done in the last encode.
 String padPlaintext(String str)
          Pad a string out to the proper length with spaces.
 String padPlaintext(String str, char pc)
          Pad a string out to the proper length with the given character.
 String toString()
          Representation of TEA class
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, wait, wait
 

Constructor Detail

TEA

public TEA(byte[] key)
Accepts key for enciphering/deciphering.
Parameters:
key - 128 bit (16 byte) key.
Throws:
ArrayIndexOutOfBoundsException - if the key isn't the correct length.

TEA

public TEA(int[] key)
Method Detail

toString

public String toString()
Representation of TEA class
Overrides:
toString in class Object

encipher

public int[] encipher(int[] v)
Encipher two ints. 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);
 
Parameters:
v - two int array as input.
Returns:
array of two ints, enciphered.

decipher

public int[] decipher(int[] v)
Decipher two ints. Replaces the original contents of the parameters with the results. The integers are usually decocted to 8 bytes. The decoction of the ints 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]);
 
Parameters:
v - int array of 2
Returns:
deciphered int array of 2

encode

public int[] encode(byte[] b,
                    int count)
Byte wrapper for encoding. Converts bytes to ints. Padding will be added if required.
Parameters:
b - incoming byte array
byte - count
Returns:
integer conversion array, possibly with padding.
See Also:
padding()

padding

public int padding()
Report how much padding was done in the last encode.
Returns:
bytes of padding added

decode

public byte[] decode(byte[] b,
                     int count)
Convert a byte array to ints and then decode. There may be some padding at the end of the byte array from the previous encode operation.
Parameters:
b - bytes to decode
count - number of bytes in the array to decode
Returns:
byte array of decoded bytes.

decode

public byte[] decode(int[] b)
Decode an integer array. There may be some padding at the end of the byte array from the previous encode operation.
Parameters:
b - bytes to decode
count - number of bytes in the array to decode
Returns:
byte array of decoded bytes.

binToHex

public String binToHex(int[] enc)
                throws ArrayIndexOutOfBoundsException
Convert an array of ints into a hex string.
Parameters:
enc - Array of integers.
Returns:
String hexadecimal representation of the integer array.
Throws:
ArrayIndexOutOfBoundsException - if the array doesn't contain pairs of integers.

getHex

public String getHex(byte[] b)
Display bytes in HEX.
Parameters:
b - bytes to display.
Returns:
string representation of the bytes.

padPlaintext

public String padPlaintext(String str,
                           char pc)
Pad a string out to the proper length with the given character.
Parameters:
str - Plain text string.
pc - Padding character.

padPlaintext

public String padPlaintext(String str)
Pad a string out to the proper length with spaces.
Parameters:
str - Plain text string.