blowfishkey.as

As3 Crypto is a cryptography library written in Actionscript 3 that provides several common algorith

			S2 = null;
			S3 = null;
			P = null;
			for (i=0;i<key.length;i++) {
				key[i]=0;
			}
			key.length = 0;
			key = null;
			Memory.gc();
		}
		
		public function encrypt(block:ByteArray, index:uint=0):void
		{
			encryptBlock(block, index, block, index);
		}

		// ==================================
		// Private Implementation
		// ==================================
	
		private function F(x:uint):uint
		{
			return (((S0[(x >>> 24)] + S1[(x >>> 16) & 0xff]) ^ S2[(x >>> 8) & 0xff]) + S3[x & 0xff]);
		}

		/**
		 * apply the encryption cycle to each value pair in the table.
		 */
		private function processTable(xl:uint, xr:uint, table:Array):void
		{
			var size:uint = table.length;
	
			for (var s:uint = 0; s < size; s += 2)
			{
				xl ^= P[0];
	
				for (var i:uint = 1; i < ROUNDS; i += 2)
				{
					xr ^= F(xl) ^ P[i];
					xl ^= F(xr) ^ P[i + 1];
				}
	
				xr ^= P[ROUNDS + 1];
	
				table[s] = xr;
				table[s + 1] = xl;
	
				xr = xl; // end of cycle swap
				xl = table[s];
			}
		}
	
		private function setKey(key:ByteArray):void
		{
			/*
			 * - comments are from _Applied Crypto_, Schneier, p338 please be
			 * careful comparing the two, AC numbers the arrays from 1, the enclosed
			 * code from 0.
			 * 
			 * (1) Initialise the S-boxes and the P-array, with a fixed string This
			 * string contains the hexadecimal digits of pi (3.141...)
			 */
			S0 = KS0.concat();
			S1 = KS1.concat();
			S2 = KS2.concat();
			S3 = KS3.concat();
			P = KP.concat();
	
			/*
			 * (2) Now, XOR P[0] with the first 32 bits of the key, XOR P[1] with
			 * the second 32-bits of the key, and so on for all bits of the key (up
			 * to P[17]). Repeatedly cycle through the key bits until the entire
			 * P-array has been XOR-ed with the key bits
			 */
			var keyLength:uint= key.length;
			var keyIndex:uint = 0;
	
			for (var i:uint = 0; i < P_SZ; i++)
			{
				// get the 32 bits of the key, in 4 * 8 bit chunks
				var data:uint = 0x0000000;
				for (var j:uint = 0; j < 4; j++)
				{
					// create a 32 bit block
					data = (data << 8) | (key[keyIndex++] & 0xff);
	
					// wrap when we get to the end of the key
					if (keyIndex >= keyLength)
					{
						keyIndex = 0;
					}
				}
				// XOR the newly created 32 bit chunk onto the P-array
				P[i] ^= data;
			}
	
			/*
			 * (3) Encrypt the all-zero string with the Blowfish algorithm, using
			 * the subkeys described in (1) and (2)
			 * 
			 * (4) Replace P1 and P2 with the output of step (3)
			 * 
			 * (5) Encrypt the output of step(3) using the Blowfish algorithm, with
			 * the modified subkeys.
			 * 
			 * (6) Replace P3 and P4 with the output of step (5)
			 * 
			 * (7) Continue the process, replacing all elements of the P-array and
			 * then all four S-boxes in order, with the output of the continuously
			 * changing Blowfish algorithm
			 */
	
			processTable(0, 0, P);
			processTable(P[P_SZ - 2], P[P_SZ - 1], S0);
			processTable(S0[SBOX_SK - 2], S0[SBOX_SK - 1], S1);
			processTable(S1[SBOX_SK - 2], S1[SBOX_SK - 1], S2);
			processTable(S2[SBOX_SK - 2], S2[SBOX_SK - 1], S3);
		}
	
		/**
		 * Encrypt the given input starting at the given offset and place the result
		 * in the provided buffer starting at the given offset. The input will be an
		 * exact multiple of our blocksize.
		 */
		private function encryptBlock(src:ByteArray, srcIndex:uint, dst:ByteArray, dstIndex:uint):void
		{
			var xl:uint = BytesTo32bits(src, srcIndex);
			var xr:uint = BytesTo32bits(src, srcIndex + 4);
	
			xl ^= P[0];
	
			for (var i:uint = 1; i < ROUNDS; i += 2)
			{
				xr ^= F(xl) ^ P[i];
				xl ^= F(xr) ^ P[i + 1];
			}
	
			xr ^= P[ROUNDS + 1];
	
			Bits32ToBytes(xr, dst, dstIndex);
			Bits32ToBytes(xl, dst, dstIndex + 4);
		}
	
		/**
		 * Decrypt the given input starting at the given offset and place the result
		 * in the provided buffer starting at the given offset. The input will be an
		 * exact multiple of our blocksize.
		 */
		private function decryptBlock(src:ByteArray, srcIndex:uint, dst:ByteArray, dstIndex:uint):void
		{
			var xl:uint = BytesTo32bits(src, srcIndex);
			var xr:uint = BytesTo32bits(src, srcIndex + 4);
	
			xl ^= P[ROUNDS + 1];
	
			for (var i:uint = ROUNDS; i > 0; i -= 2)
			{
				xr ^= F(xl) ^ P[i];
				xl ^= F(xr) ^ P[i - 1];
			}
	
			xr ^= P[0];
	
			Bits32ToBytes(xr, dst, dstIndex);
			Bits32ToBytes(xl, dst, dstIndex + 4);
		}
	
		private function BytesTo32bits(b:ByteArray, i:uint):uint
		{
			return ((b[i] & 0xff) << 24) | ((b[i + 1] & 0xff) << 16) | ((b[i + 2] & 0xff) << 8) | ((b[i + 3] & 0xff));
		}
	
		private function Bits32ToBytes(i:uint, b:ByteArray, offset:uint):void
		{
			b[offset + 3] = i;
			b[offset + 2] = (i >> 8);
			b[offset + 1] = (i >> 16);
			b[offset] = (i >> 24);
		}
		
		public function toString():String {
			return "blowfish";
		}
	
	}
		
}