/* Java Crypto Functions Source Code */

/*
 Placed into Public Domain 
 2015, Karl-Uwe Frank
*/

import java.io.IOException;
import java.security.MessageDigest;


// -----------------------------------------
// HMAC
//
// H(K XOR opad, H(K XOR ipad, text))
//
// MD5(key XOR opad, MD5(key XOR ipad, text))
//
// ipad = 0x36, opad = 0x5c
//
// Test Vectors at https://tools.ietf.org/html/rfc4231
//								 https://datatracker.ietf.org/doc/rfc2202/?include_text=1
//								 https://en.wikipedia.org/wiki/Hmac#Examples
//
public static byte[] hmac(String hashType, byte[] key, byte[] message) throws Exception {
	// md5, sha-1, sha-256 = 64
	// sha-384, sha-512    = 128
	//		
	int blocksize = 64;
	int keylength = (int)key.length;
	
	if (hashType.toLowerCase().equals("sha-384") || hashType.toLowerCase().equals("sha-512")) {
		blocksize = 128;
	}
			
	byte[] Hmac_key  = new byte[blocksize];
	byte[] inner_pad = new byte[blocksize];
	byte[] outer_pad = new byte[blocksize];
	byte[] byteHMac  = new byte[blocksize];

	// If the Key is to long use it's Hash  
	if (keylength > blocksize){
		// adjust the Key Length
		keylength = MessageDigest.getInstance(hashType).getDigestLength();
		byte[] temp = new byte[keylength];

		temp = hashByte(hashType, key);

		for (int i=0; i<keylength; i++) Hmac_key[i] = temp[i];
		} 
	else {
		// Pass the key to the Hmac_key Array
		for (int i=0; i<keylength; i++) {
			Hmac_key[i] = key[i];
		}		
	}
	
	// If the Key is to short fill it up with Zero
	if (keylength < blocksize){
		for (int i=keylength; i<blocksize; i++){
			Hmac_key[i] = (byte)0x00;
		}
	}
	
	// Generate the Pads
	for (int i=0; i<blocksize; i++){
		inner_pad[i] = (byte)0x36;
		outer_pad[i] = (byte)0x5c;
	}

	// XOR the Key against the Pads
	for (int i=0; i<keylength; i++){
		inner_pad[i] = (byte)(inner_pad[i] ^ Hmac_key[i]);
		outer_pad[i] = (byte)(outer_pad[i] ^ Hmac_key[i]);
	}
	
	// Calculate the HMAC
	//
	// md5(outer_pad + md5(inner_pad + message)
	byteHMac = hashByte(hashType, bf.concatByteArrays( outer_pad, hashByte(hashType, bf.concatByteArrays(inner_pad, message)) ));
			
	// Return the HMAC
	return byteHMac;
}


//-----------------------------------------
// 
// Password based Key Derivation Function
//
// Test Vectors at https://tools.ietf.org/html/rfc6070
//
//      Input:
//        key = "password"
//        salt = "salt"
//        c = 1
//        dkLen = 20
// 
//      Output: 0c60c80f961f0e71f3a9b524af6012062fe037a6
// 
//      Input:
//        key = "password"
//        salt = "salt"
//        c = 2
//        dkLen = 20
// 
//      Output: ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957
// 
//      Input:
//        key = "password"
//        salt = "salt"
//        c = 4096
//        dkLen = 20
// 
//      Output: 4b007901b765489abead49d926f721d065a429c1
//             
public static byte[] PBKDF2(String hashType, byte[] key, byte[] salt, int c, int dkLen) throws Exception {
	int hLen 			 = MessageDigest.getInstance(hashType).getDigestLength();
	int blockCount = (int)(Math.ceil(dkLen / hLen))+1;
	int saltLen    = salt.length;
	int DK_offset	 = 0;

	// Initialse the Arrays
	byte[] T_i = {0};		
	byte[] U_i = {0};		
	byte[] DK  = new byte[dkLen];
	
	// "i" has to start with the Value 1
	for (int i=1; i<=blockCount; i++) {
		// Encoded "i" as 4 Bytes (Big Endian)
		byte[] i4Byte = new byte[4];
		i4Byte = bf.LEndianToByteArray(i);
		
		// Concatenate Big Endian Encoded "i" to the Salt
		U_i = new byte[saltLen +4];		
		for (int k=0; k<saltLen; k++) U_i[k] = salt[k];
		for (int k=0; k<4; k++) U_i[k + saltLen] = i4Byte[k];
				
		// Perform the first Iteration
		T_i = new byte[hLen];	
		T_i = hmac(hashType, key, U_i);

		// Pass over T_i to U_i
		U_i = new byte[T_i.length];		
		for (int k=0; k<T_i.length; k++) U_i[k] = T_i[k];

		// Perform the remaining Iterations
		for (int j=1; j<c; j++) {
			U_i = hmac(hashType, key, U_i);
			
			// Xor T_i with U_i
			for (int k=0; k<hLen; k++) T_i[k] = (byte)(T_i[k] ^ U_i[k]);
		}

		// Concatenate the new Hash Value to the unfinished derived Key        
		int T_i_count = 0;
		for (int k=DK_offset; k<(DK_offset+hLen); k++) {
			if (k > dkLen-1) break;
			DK[k] = T_i[T_i_count++];
		}
		DK_offset += hLen;
 
  // Return the finaly derived Key
  return DK;
}



//-----------------------------------------
//
// Convert Int32 to Byte Array
//
public static byte[] int32ToByteArray(int int32) {
  byte[] b = new byte[4];
  
  b[0] = (byte)((int32 >> 24) & 0xff);
  b[1] = (byte)((int32 >> 16) & 0xff);
  b[2] = (byte)((int32 >>  8) & 0xff);
  b[3] = (byte)( int32        & 0xff);

  return b;
}


//-----------------------------------------
//
// Calculate Hash Value
//
public static byte[] hashByte(String hashType, byte[] byteArray) throws Exception {
  MessageDigest md = MessageDigest.getInstance(hashType);
  
  md.reset();
  md.update(byteArray);

  byte[] digestBytesArray = md.digest();

  return digestBytesArray;
}


//-----------------------------------------
//
// Concatenate two Byte Arrays
//
public static byte[] concatByteArrays(byte[] a, byte[] b) throws Exception {
  ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
  outputStream.write( a );
  outputStream.write( b );
  
  return outputStream.toByteArray();
}