Javascript -Java compatible encryption

Implementation of Tiny Encryption Algorithm

How to write a Java and JavaScript compatible implementation of Tiny Encryption Algorithm to encrypt some data exchanged between navigator and Java application server.

Article published on 7 April 2011

last modification on 30 May 2016

by Emeric Nasi

License : Copyright Emeric Nasi, some rights reserved
This work is licensed under a Creative Commons Attribution 4.0 International License.

Introduction

I decided a few weeks ago to create my own Java "stealth malware" I called Bromo. This malware’s goal is to test and demonstrate Java security and insecurity in a corporate environment by targeting a Java application. For example an "evil" Jar that could be included by a developer.
I adapted Bromo to Web Application trojaning so that a distant attacker could control from anywhere via Firefox for example. The problem that occurred to me was to secure the communication between the attacker navigator and the Web server.
In this case I do not have the hand on the server, and I need to be as stealthy as possible. Moreover I need an encryption system that can prevent anyone (WAF and admins) from reading the content of the requests and responses I send to the malware.
That’s why it led me to use Javascript encryption.
In this article I do not describe the malware itself.
This article sections are :

The encryption algorithm I chose
The Java implementation of the algorithm
The Javascript implementation of the algorithm

The difficulty here is to have compatible implementation between Java and Javascript (which is not a piece of cake).

Warning : I do not recommend to use Javascript encryption. It is often the worst choice. However there are cases (like mine) where it can be helpful. If you want to read more about the pros and the cons of Javascript encryption read this article.

I. Tiny Encryption Algorithm

Also called "TEA" or just "Tiny", the Tiny Encryption Algorithm was first presented in 1994 by David Wheeler and Roger Needham from Cambridge.
TEA encryption relies on a cipher operation that encrypts two 32bit Integers using a 4*32bits key.
This algorithm has two main assets. First it is not subject to any sort of patent or license, next it offers a strong cryptography in regard to the easiness of its implementation.
If you want to learn more about TEA, you should have a look at the TEA official page. This website presents a lot of TEA implementation and I relied heavily on it when I had to build my own Java and JavaScript implementation.

II. Java TEA implementation

II.1 About Java TEA implementation

The next Java TEA implementation is based on various TEA implementation you can find on the TEA official page. The main problem with a Java TEA implementation is the lack of "unsigned" types in the Java language. The TEA algorithm relies on fast shifting on unsigned 32-bits integers, and that is also the case for other language implementation. This suggests we will have a compatibility problem between Java and other language implementation.
Because we cannot force Java to use unsigned int we will have to use a classical Java TEA implementation, and force unsigned int usage on the other side (JavaScript implementation).

II.2 Utility functions

The Java implementation part is not a big problem, base 64 conversion, int[] to byte[] and other utility function can be found easily on the Internet.
You can always email me if you want the complete source codes.

II.3 The TEA cipher

TEA is mainly a cipher operating on blocks of 64 bits. The next encipher and decipher are very common to all language TEA implementations. However you can notice the use of the >>> operator witch is an unsigned right shift (all bits are shift from one position to the right, the left positions are filled with zeros).

/**
	 * Contains the 128 bit key.
	 */
	private int __key__[];
	
	/**
	 * Encipher two ints.
	 * Replaces the original contents of the parameters with the results.
	 * @param v two int array as input.
	 * @return array of two enciphered ints.
	 */
	private int[] encipher(final int v[]) {
		int y = v[0];
		int z = v[1];
		int sum = 0;
		final int delta = 0x9E3779B9;
		final int a = this.__key__[0];
		final int b = this.__key__[1];
		final int c = this.__key__[2];
		final int d = this.__key__[3];
		int n = 32;

		while (n-- > 0) {
			sum += delta;
			y += (z << 4) + a ^ z + sum ^ (z >>> 5) + b;
			z += (y << 4) + c ^ y + sum ^ (y >>> 5) + d;
		}

		v[0] = y;
		v[1] = z;

		return v;
	}
	
	/**
	 * Decipher two ints.
	 * Replaces the original contents of the parameters with the results.
	 * @param v 2 int array 
	 * @return deciphered 2 int array
	 */
	private int[] decipher(final int v[]) {
		int y = v[0];
		int z = v[1];
		int sum = 0xC6EF3720;
		final int delta = 0x9E3779B9;
		final int a = this.__key__[0];
		final int b = this.__key__[1];
		final int c = this.__key__[2];
		final int d = this.__key__[3];
		int n = 32;

		while (n-- > 0) {
			z -= (y << 4) + c ^ y + sum ^ (y >>> 5) + d;
			y -= (z << 4) + a ^ z + sum ^ (z >>> 5) + b;
			sum -= delta;
		}

		v[0] = y;
		v[1] = z;

		return v;
	}

II.4 Encryption/Decryption

The next functions are the entry point for the TEA algorithm.
The data en encode or decode is stored in an array of bytes.

/**
  	* Amount of padding added in byte --> integer conversion.
  	*/
	 private int __padding__;
   
	/**
	 * Turns a given byte array into an encrypted integers array. 
	 * @param b incoming <code>byte array
	 * @param byte count
	 * @return integer conversion array, possibly with padding.
	 * @see #padding
	 */
	private int[] encode(final byte b[], final int count) {
		int j, i;
		int bLen = count;
		byte bp[] = b;
		// We check if we need to add some padding
		this.__padding__ = bLen % 8;
		if (this.__padding__ != 0) // Add some padding, if necessary.
		{
			this.__padding__ = 8 - bLen % 8;
			bp = new byte[bLen + this.__padding__];
			System.arraycopy(b, 0, bp, 0, bLen);
			bLen = bp.length;
		}

		final int intCount = bLen / 4;
		final int r[] = new int[2];
		final int out[] = new int[intCount];
		// Here we encipher all the bytes
		for (i = 0, j = 0; j < bLen; j += 8, i += 2) {
			// 8 byte to 2 int conversion
			r[0] = bp[j] << 24 | (bp[j + 1] & 0xff) << 16 | (bp[j + 2] & 0xff) << 8 | bp[j + 3] & 0xff;
			r[1] = bp[j + 4] << 24 | (bp[j + 5] & 0xff) << 16 | (bp[j + 6] & 0xff) << 8 | bp[j + 7] & 0xff;
			encipher(r);
			// Store enciphered bytes in "out" 2 bytes array
			out[i] = r[0];
			out[i + 1] = r[1];
		}

		return out;
	}
  
	/**
	 * Decode an integer array. There may be some padding at the end of the byte array from the previous encode operation.
	 * @param b bytes to decode
	 * @return byte array of decoded bytes.
	 */
	private byte[] decode(final int b[]) {
		// create the large number and start stripping ints out, two at a time.
		final int intCount = b.length;

		final byte outb[] = new byte[intCount * 4];
		final int tmp[] = new int[2];

		// decipher all the ints.
		int i, j;
		for (j = 0, i = 0; i < intCount; i += 2, j += 8) {
			tmp[0] = b[i];
			tmp[1] = b[i + 1];
			decipher(tmp);
			outb[j] = (byte) (tmp[0] >>> 24);
			outb[j + 1] = (byte) (tmp[0] >>> 16);
			outb[j + 2] = (byte) (tmp[0] >>> 8);
			outb[j + 3] = (byte) tmp[0];
			outb[j + 4] = (byte) (tmp[1] >>> 24);
			outb[j + 5] = (byte) (tmp[1] >>> 16);
			outb[j + 6] = (byte) (tmp[1] >>> 8);
			outb[j + 7] = (byte) tmp[1];
		}

		return outb;
	}

III. JavaScript TEA implementation

III.1 About JavaScript TEA implementation

The goal of this implementation is to provide conversion functions between JavaScript strings and encrypted base64 strings. These base64 encrypted strings should be compatible with the Java implementation encrypted strings.
Even if there are a lot of good TEA JavaScript implementation on the Internet, none of them are "Java compliant". Remember, Java does not manage unsigned integers! The problem we have is that all JavaScript integer are unsigned by default. And all the existing TEA JavaScript implementation use unsigned integers (which is normal because TEA is supposed to be more efficient with unsigned integers).
My JavaScript TEA implementation is an extension of the JavaScript TEA implementation of Chris Veness.
Here is the code header :

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
/* Tiny Encryption Algorithm implementation in JavaScript                                         */
/* JavaScript implementation Based on : Chris Veness, Movable Type Ltd: www.movable-type.co.uk    */
/* Java compatibility added by Emeric Nasi                                                        */
/* About Java compatibility : 
	The javascript implementation was modified to use signed integer due to the lack of 
	unsigned types in Java.
	The output and input of the encrypt/decrypt methods are a base64 encoding of and UTF-8 string */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
/*  Algorithm: David Wheeler & Roger Needham, Cambridge University Computer Lab                   */
/*             http://www.cl.cam.ac.uk/ftp/papers/djw-rmn/djw-rmn-tea.html (1994)                 */
/*             http://www.cl.cam.ac.uk/ftp/users/djw3/xtea.ps (1997)                              */
/*             http://www.cl.cam.ac.uk/ftp/users/djw3/xxtea.ps (1998)                             */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */

III.2 Utility functions

Fist we need to define a set of utility functions that we will need in our TEA implementation.

Note : Notice the use of "integer|0" operation. This is the workaround used to force unsigned integers into signed integers.

/**
 *	Convert an int into 4 bytes  
 */
function getBytes( x ){
	//alert("x :"+x);
	var bytes = [];
	var padding = 0;
	var i = 4;
	do {
		bytes[--i] = ((x & (255))|0);
		x = ((x|0)>>8)|0;
		bytes[i] = (bytes[i]|0);
	} while ( i )
	return bytes;
}
 
/**
 *	Convert 4 chars (8 bits) of s to a numeric long.
 */
function Str4ToLong(s)  // 
{
	var key = (s.charCodeAt(0) << 24) | (((s.charCodeAt(1)) & 0xff) << 16)
					| (((s.charCodeAt(2)) & 0xff) << 8) | ((s.charCodeAt(3)) & 0xff);			
	return key;
}
 
/**
 *	Convert a numeric long to 4 8 bits chars string. 
 */
function LongToStr4(v){
	  // Get bytes corresponding to int				
	  var bytes = getBytes(v);	
	  // Convert the bytes to a String				
	  var s = "";
	  s+=String.fromCharCode(bytes[0]);
	  s+=String.fromCharCode(bytes[1]);	
	  s+=String.fromCharCode(bytes[2]);	
	  s+=String.fromCharCode(bytes[3]);	
	  return(s);
}

In my JavaScript implementation I used Base64 and UFT-8 encoding/decoding functions. Because they are just a copy/past from the Chris Veness JavaScript TEA implementation, I will not describe them here. If you want to implement the same system as I did, you can get these functions source code here.

III.3 The TEA cipher

As in the Java implementation, the cipher functions are the heart of the encryption algorithm.
The Tea cipher and decipher functions take 2 integers and apply the cipher in part I.2.

/**
 * Encipher two ints.
 * Replaces the original contents of the parameters with the results.
 * The integers are usually created from 8 bytes.
 * NOTE : All operation are made using signed integers for java/javascript compatibility.
 *	@param v 2 int array
 *	@param k 4 int key
 *  @return 2 encrypted ints.  
 */	
function cipher(v, k){

    var y = v[0], z = v[1];
    // Note that delta is forced to the signed int value corresponding to 0x9E3779B9
    var delta = -1640531527, limit = delta*32, sum = 0;
  
    var a = new Number(k[0]);
	var b = new Number(k[1]);
	var c = new Number(k[2]);
	var d = new Number(k[3]);
	
	var n = 32;
	while (n-- > 0) {
		sum = ((delta+sum)|0);	
		y += ((((z << 4) + a)|0) ^ ((z + sum)|0) ^ (((z >>> 5) + b)|0))|0;
		y = y|0;
		z += ( ((((y << 4) + c)|0) ^ ((y + sum)|0) ^ (((y >>> 5) + d)|0))|0);
		z = z|0;	
	}

  	v[0] = y; 
	v[1] = z;
}
 
/**
 * Decipher two ints.
 * Replaces the original contents of the parameters with the results.
 * The integers are  decoded to 8 bytes.
 * NOTE : All operations are made using signed integers for java/javascript compatibility.
 *	@param v 2 int array
 *	@param k 4 int key
 *  @return 2 encrypted ints.  
 */	
function decipher(v, k){
    var y = v[0], z = v[1];
	 // Note that delta is forced to the signed int value corresponding to 0x9E3779B9
    var delta = -1640531527;
    var sum = delta*32;

	var a = new Number(k[0]);
	var b = new Number(k[1]);
	var c = new Number(k[2]);
	var d = new Number(k[3]);
	var n = 32;
    while (n-- > 0) {
		z -= ( ((((y << 4) + c)|0) ^ ((y + sum)|0) ^ (((y >>> 5) + d)|0))|0);
	    z = z|0;
		y -= ((((z << 4) + a)|0) ^ ((z + sum)|0) ^ (((z >>> 5) + b)|0))|0;
	    y = y|0;
		sum = ((sum-delta)|0);	
	}

	v[0] = y;
	v[1] = z;
}

III.4 Encryption/Decryption

These are the entry points of our JavaScript TEA implementation.

/**
 *	Encryption using Tea algorithm.
 *	@param val The string we want to encrypt
 *	@param key The 16 byte encryption key
 *  	@return base64 encoding of encrypted val.  
 */	
function encrypt(val, key)
{
  // 128 bits (16 chars) of string 'key' are used to encrypt string 'val'; function
  // returns encrypted version of 'val'.
  var v = new Array(2), k = new Array(4), s = "", i;
  val = Utf8.encode(val);	// Convert val to UTF-8

  k[0] = Str4ToLong(key.substr(0,4));
  k[1] = Str4ToLong(key.substr(4,4));
  k[2] = Str4ToLong(key.substr(8,4));
  k[3] = Str4ToLong(key.substr(12,4));
 	
  for (i=0; i<val.length; i+=8) {  
        
		// Convert 64 bits (8 chars) into 2 32 bits integers
		v[0] = Str4ToLong(val.substr(i,4));
		v[1] = Str4ToLong(val.substr(i+4,4));

		// Cipher the two integers
		cipher(v, k);
  
		// Fill array with encrypted integers
		s+=LongToStr4(v[0]);
		s+=LongToStr4(v[1]);
	}
	return(Base64.encode(s));
}
 
/**
 *	Decryption using Tea algorithm.
 *	@param b64val The base64 encoding of val we want to decrypt
 *	@param key The 16 byte encryption key
 *  @return The original string.  
 */	
function decrypt(b64val, key){
  	
  var v = new Array(2), k = new Array(4), s = "", i;
  var val = Base64.decode(b64val); // Base64 decode of val.
	
  k[0] = Str4ToLong(key.substr(0,4));
  k[1] = Str4ToLong(key.substr(4,4));
  k[2] = Str4ToLong(key.substr(8,4));
  k[3] = Str4ToLong(key.substr(12,4));

  val = unescape(val); // corrected NVS 2005.04.27
  // decode val into s in 64-bit (8 char) blocks	
  for (i=0; i<val.length; i+=8) {  
    v[0] = Str4ToLong(val.substr(i,4));
    v[1] = Str4ToLong(val.substr(i+4,4));
    decipher(v, k);
    s += LongToStr4(v[0]) + LongToStr4(v[1]);
  }
  
  // strip trailing null chars resulting from filling 4-char blocks
  if (s.indexOf("\x00") != -1) {  
      s = s.substr(0, s.indexOf("\x00"));
  }
  
  return(Utf8.decode(s));
}

As you can see, encryption/decryption compatibility between language is not always something trivial. If you wonder why Java does not implement unsigned integers you can always have a look at that discussion on the stackoverflow Q&A.
Concerning JavaScript, there are a lot of implementation of encryption function out there but remember that JavaScript encryption is almost never a good solution, and that you have to deal with the problems of navigators compatibility and server language compatibility.
I did not post all the source code in this article, if you want to have the complete JavaScript or Java source you can email me at emeric.nasi[at]sevagas.com