/*

* Copyright (c) 2001-2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  EAP and WLAN authentication protocols.

*

*/

// This is enumeration of EAPOL source code.

#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

	#undef EAP_FILE_NUMBER_ENUM

	#define EAP_FILE_NUMBER_ENUM 4 

	#undef EAP_FILE_NUMBER_DATE 

	#define EAP_FILE_NUMBER_DATE 1127594498 

#endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

#include "eap_am_memory.h"

#include "eap_am_crypto_md4.h"

//--------------------------------------------------

#if 1

	#define EAP_MD4_TRACE_DEBUG EAP_TRACE_DEBUG

#else

	#define EAP_MD4_TRACE_DEBUG(tools, flags, params)

#endif

#if defined(USE_EAP_TRACE)

	static const u32_t EAP_TRACE_MASK_MD4 = eap_am_tools_c::eap_trace_mask_crypto_md4;

#endif //#if defined(USE_EAP_TRACE)	

//--------------------------------------------------

EAP_FUNC_EXPORT eap_am_crypto_md4_c::~eap_am_crypto_md4_c()

{

	hash_cleanup();

}

//--------------------------------------------------

EAP_FUNC_EXPORT eap_am_crypto_md4_c::eap_am_crypto_md4_c(

	abs_eap_am_tools_c * const tools)

	: m_am_tools(tools)

	, m_saved_data(tools)

	, m_full_hashed_data_length(0ul)

	, m_is_valid(false)

{

	m_H[0] = 0;

	m_W_in_host_order[0] = 0;

	if (m_saved_data.get_is_valid() == false)

	{

		return;

	}

	eap_status_e status = hash_init();

	if (status != eap_status_ok)

	{

		return;

	}

	set_is_valid();

}

//------------------------------------------------------------

/**

 * The set_is_invalid() function sets the state of the eap_am_crypto_md4_c

 * object invalid. 

 * The eap_am_crypto_md4_c object calls this function after it is initialized.

 */

EAP_FUNC_EXPORT void eap_am_crypto_md4_c::set_is_invalid()

{

	m_is_valid = false;

}

//------------------------------------------------------------

/**

 * The set_is_valid() function sets the state of the eap_am_crypto_md4_c

 * object valid. 

 * The eap_am_crypto_md4_c object calls this function after it is initialized.

 */

EAP_FUNC_EXPORT void eap_am_crypto_md4_c::set_is_valid()

{

	m_is_valid = true;

}

//------------------------------------------------------------

/**

 * The get_is_valid() function returns the status of the eap_am_crypto_md4_c

 * object. 

 * True indicates the object is allocated successfully.

 */

EAP_FUNC_EXPORT bool eap_am_crypto_md4_c::get_is_valid()

{

	return m_is_valid;

}

//--------------------------------------------------

inline u32_t eap_am_crypto_md4_c::eap_md4_rotate_left(

	const u32_t value,

	const u32_t shift

	)

{

	return (value << shift) | (value >> (32ul - shift));

}

//--------------------------------------------------

inline void eap_am_crypto_md4_c::eap_md4_FF(

	const u32_t index,

	u32_t * const A,

	const u32_t B,

	const u32_t C,

	const u32_t D,

	const u32_t X,

	const u32_t S

	)

{	

	EAP_UNREFERENCED_PARAMETER(index);

	*A += eap_md4_F(B, C, D) + X;

	*A = eap_md4_rotate_left(*A, S);

	EAP_MD4_TRACE_DEBUG(m_am_tools, EAP_TRACE_MASK_MD4,

					(EAPL("MD4: t=%d\t%08x\t%08x\t%08x\t%08x\t%08x\t% 8d\n"),

					 index, *A, B, C, D, X, S));

}

//--------------------------------------------------

inline void eap_am_crypto_md4_c::eap_md4_GG(

	const u32_t index,

	u32_t * const A,

	const u32_t B,

	const u32_t C,

	const u32_t D,

	const u32_t X,

	const u32_t S

	)

{

	EAP_UNREFERENCED_PARAMETER(index);

	*A += eap_md4_G(B, C, D) + X + 0x5a827999;

	*A = eap_md4_rotate_left(*A, S);

	EAP_MD4_TRACE_DEBUG(m_am_tools, EAP_TRACE_MASK_MD4,

					(EAPL("MD4: t=%d\t%08x\t%08x\t%08x\t%08x\t%08x\t% 8d\n"),

					 index, *A, B, C, D, X, S));

}

//--------------------------------------------------

inline void eap_am_crypto_md4_c::eap_md4_HH(

	const u32_t index,

	u32_t * const A,

	const u32_t B,

	const u32_t C,

	const u32_t D,

	const u32_t X,

	const u32_t S

	)

{

	EAP_UNREFERENCED_PARAMETER(index);

	*A += eap_md4_H(B, C, D) + X + 0x6ed9eba1;

	*A = eap_md4_rotate_left(*A, S);

	EAP_MD4_TRACE_DEBUG(m_am_tools, EAP_TRACE_MASK_MD4,

					(EAPL("MD4: t=%d\t%08x\t%08x\t%08x\t%08x\t%08x\t% 8d\n"),

					 index, *A, B, C, D, X, S));

}

//--------------------------------------------------

inline u32_t eap_am_crypto_md4_c::eap_md4_F(

	const u32_t X,

	const u32_t Y,

	const u32_t Z

	)

{

	return (X & Y) | ((~X) & Z);

}

//--------------------------------------------------

inline u32_t eap_am_crypto_md4_c::eap_md4_G(

	const u32_t X,

	const u32_t Y,

	const u32_t Z

	)

{

	return (X & Y) | (X & Z) | (Y & Z);

}

//--------------------------------------------------

inline u32_t eap_am_crypto_md4_c::eap_md4_H(

	const u32_t X,

	const u32_t Y,

	const u32_t Z

	)

{

	return (X ^ Y ^ Z);

}

//--------------------------------------------------

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_md4_c::eap_md4_process_data(

	const u32_t * const W,

	const u32_t W_count

	)

{

	if (W == 0

		//|| (reinterpret_cast<u32_t>(W) % sizeof(u32_t)) != 0

		|| W_count == 0

		|| (W_count % EAP_AM_CRYPTO_MD4_BLOCK_u32_COUNT) != 0)

	{

		EAP_ASSERT_ANYWAY;

		EAP_SYSTEM_DEBUG_BREAK();

		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

	}

	eap_status_e status = eap_status_ok;

	// Array of 16 temporary 32-bit unsigned integers.

	u32_t count = W_count / EAP_AM_CRYPTO_MD4_BLOCK_u32_COUNT;	

	for (u32_t ind = 0ul; ind < count; ind++)

	{	

		for (u32_t ind_W = 0ul; ind_W < EAP_AM_CRYPTO_MD4_BLOCK_u32_COUNT

				 ; ind_W++)

		{

			// Here we must read data in 8-bit blocks bacause W can be aligned at any position.

			const u8_t * const data = reinterpret_cast<const u8_t *>(&W[ind*EAP_AM_CRYPTO_MD4_BLOCK_u32_COUNT+ind_W]);

			m_W_in_host_order[ind_W]

				= (data[0] <<  0)

				| (data[1] <<  8)

				| (data[2] << 16)

				| (data[3] << 24);

		} // for()

		status = eap_md4_transform_host_order(

			m_W_in_host_order,

			EAP_AM_CRYPTO_MD4_BLOCK_u32_COUNT);

		if (status != eap_status_ok)

		{

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

	} // for()

	return EAP_STATUS_RETURN(m_am_tools, status);

}

//--------------------------------------------------

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_md4_c::eap_md4_transform_host_order(

	const u32_t * const W,

	const u32_t W_count

	)

{

	u32_t A = m_H[0];

	u32_t B = m_H[1];

	u32_t C = m_H[2];

	u32_t D = m_H[3];

	if (W == 0

		//|| (reinterpret_cast<u32_t>(W) % sizeof(u32_t)) != 0

		|| W_count != EAP_AM_CRYPTO_MD4_BLOCK_u32_COUNT)

	{

		EAP_ASSERT_ANYWAY;

		EAP_SYSTEM_DEBUG_BREAK();

		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

	}

	const u32_t * const X = W;

#if defined(_DEBUG)

	EAP_MD4_TRACE_DEBUG(m_am_tools, EAP_TRACE_MASK_MD4,

					(EAPL("MD4: A=%08x\tB=%08x\tC=%08x\tD=%08x\n"),

					 A, B, C, D));

	u32_t ind;

	for (ind = 0ul; ind < W_count; ind++)

	{

		EAP_MD4_TRACE_DEBUG(m_am_tools, EAP_TRACE_MASK_MD4,

					(EAPL("MD4: W[%d]=%08x\n"),

					 ind,

					 W[ind]));

	} // for()

	EAP_MD4_TRACE_DEBUG(m_am_tools, EAP_TRACE_MASK_MD4,

					(EAPL("MD4: \n")));

	for (ind = 0ul; ind < sizeof(X)/sizeof(X[0]); ind++)

	{

		EAP_MD4_TRACE_DEBUG(m_am_tools, EAP_TRACE_MASK_MD4,

					(EAPL("MD4: X[%d]=%08x\n"),

					 ind,

					 X[ind]));

	} // for()

	EAP_MD4_TRACE_DEBUG(m_am_tools, EAP_TRACE_MASK_MD4,

					(EAPL("MD4: % 5s\t% 8s\t% 8s\t% 8s\t% 8s\t% 8s\t% 8s\n"),

					 "index", "A", "B", "C", "D", "X", "shift"));

#endif //#if defined(_DEBUG)

	eap_md4_FF( 1, &A, B, C, D, X[ 0], eap_md4_const_S11);

	eap_md4_FF( 2, &D, A, B, C, X[ 1], eap_md4_const_S12);

	eap_md4_FF( 3, &C, D, A, B, X[ 2], eap_md4_const_S13);

	eap_md4_FF( 4, &B, C, D, A, X[ 3], eap_md4_const_S14);

	eap_md4_FF( 5, &A, B, C, D, X[ 4], eap_md4_const_S11);

	eap_md4_FF( 6, &D, A, B, C, X[ 5], eap_md4_const_S12);

	eap_md4_FF( 7, &C, D, A, B, X[ 6], eap_md4_const_S13);

	eap_md4_FF( 8, &B, C, D, A, X[ 7], eap_md4_const_S14);

	eap_md4_FF( 9, &A, B, C, D, X[ 8], eap_md4_const_S11);

	eap_md4_FF(10, &D, A, B, C, X[ 9], eap_md4_const_S12);

	eap_md4_FF(11, &C, D, A, B, X[10], eap_md4_const_S13);

	eap_md4_FF(12, &B, C, D, A, X[11], eap_md4_const_S14);

	eap_md4_FF(13, &A, B, C, D, X[12], eap_md4_const_S11);

	eap_md4_FF(14, &D, A, B, C, X[13], eap_md4_const_S12);

	eap_md4_FF(15, &C, D, A, B, X[14], eap_md4_const_S13);

	eap_md4_FF(16, &B, C, D, A, X[15], eap_md4_const_S14);

	eap_md4_GG(17, &A, B, C, D, X[ 0], eap_md4_const_S21);

	eap_md4_GG(18, &D, A, B, C, X[ 4], eap_md4_const_S22);

	eap_md4_GG(19, &C, D, A, B, X[ 8], eap_md4_const_S23);

	eap_md4_GG(20, &B, C, D, A, X[12], eap_md4_const_S24);

	eap_md4_GG(21, &A, B, C, D, X[ 1], eap_md4_const_S21);

	eap_md4_GG(22, &D, A, B, C, X[ 5], eap_md4_const_S22);

	eap_md4_GG(23, &C, D, A, B, X[ 9], eap_md4_const_S23);

	eap_md4_GG(24, &B, C, D, A, X[13], eap_md4_const_S24);

	eap_md4_GG(25, &A, B, C, D, X[ 2], eap_md4_const_S21);

	eap_md4_GG(26, &D, A, B, C, X[ 6], eap_md4_const_S22);

	eap_md4_GG(27, &C, D, A, B, X[10], eap_md4_const_S23);

	eap_md4_GG(28, &B, C, D, A, X[14], eap_md4_const_S24);

	eap_md4_GG(29, &A, B, C, D, X[ 3], eap_md4_const_S21);

	eap_md4_GG(30, &D, A, B, C, X[ 7], eap_md4_const_S22);

	eap_md4_GG(31, &C, D, A, B, X[11], eap_md4_const_S23);

	eap_md4_GG(32, &B, C, D, A, X[15], eap_md4_const_S24);

	eap_md4_HH(33, &A, B, C, D, X[ 0], eap_md4_const_S31);

	eap_md4_HH(34, &D, A, B, C, X[ 8], eap_md4_const_S32);

	eap_md4_HH(35, &C, D, A, B, X[ 4], eap_md4_const_S33);

	eap_md4_HH(36, &B, C, D, A, X[12], eap_md4_const_S34);

	eap_md4_HH(37, &A, B, C, D, X[ 2], eap_md4_const_S31);

	eap_md4_HH(38, &D, A, B, C, X[10], eap_md4_const_S32);

	eap_md4_HH(39, &C, D, A, B, X[ 6], eap_md4_const_S33);

	eap_md4_HH(40, &B, C, D, A, X[14], eap_md4_const_S34);

	eap_md4_HH(41, &A, B, C, D, X[ 1], eap_md4_const_S31);

	eap_md4_HH(42, &D, A, B, C, X[ 9], eap_md4_const_S32);

	eap_md4_HH(43, &C, D, A, B, X[ 5], eap_md4_const_S33);

	eap_md4_HH(44, &B, C, D, A, X[13], eap_md4_const_S34);

	eap_md4_HH(45, &A, B, C, D, X[ 3], eap_md4_const_S31);

	eap_md4_HH(46, &D, A, B, C, X[11], eap_md4_const_S32);

	eap_md4_HH(47, &C, D, A, B, X[ 7], eap_md4_const_S33);

	eap_md4_HH(48, &B, C, D, A, X[15], eap_md4_const_S34);

	m_H[0] += A;

	m_H[1] += B;

	m_H[2] += C;

	m_H[3] += D;

	EAP_MD4_TRACE_DEBUG(m_am_tools, EAP_TRACE_MASK_MD4,

					(EAPL("MD4: digest=\t%08x\t%08x\t%08x\t%08x\n"),

					 m_H[0], m_H[1], m_H[2], m_H[3]));

	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

}

//--------------------------------------------------

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_md4_c::copy_message_digest(

	void * const output,

	u32_t * const max_output_size)

{

	if (output == 0

		|| max_output_size == 0

		|| *max_output_size < EAP_AM_CRYPTO_MD4_DIGEST_BUFFER_BYTE_SIZE)

	{

		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

	}

#if defined(EAP_LITTLE_ENDIAN)

	m_am_tools->memmove(output, m_H, EAP_AM_CRYPTO_MD4_DIGEST_BUFFER_BYTE_SIZE);

#elif defined(EAP_BIG_ENDIAN)

	// We must change the data from host order to network order.

	u32_t * const tmp_H = static_cast<u32_t *>(output);

	for (u32_t ind = 0ul; ind < EAP_AM_CRYPTO_MD4_DIGEST_BUFFER_u32_COUNT

			 ; ind++)

	{

		tmp_H[ind] = eap_htonl(m_H[ind]);

	} // for()

#else

#error ERROR: define EAP_LITTLE_ENDIAN (byte 0 is least significant \

(i386)) or EAP_BIG_ENDIAN (byte 0 is most significant (mc68k)).

#endif

	*max_output_size = EAP_AM_CRYPTO_MD4_DIGEST_BUFFER_BYTE_SIZE;

	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

}

//--------------------------------------------------

/**

 * This function returns the size of message digest of HASH-algorithm.

 */

EAP_FUNC_EXPORT u32_t eap_am_crypto_md4_c::get_digest_length()

{

	return EAP_AM_CRYPTO_MD4_DIGEST_BUFFER_BYTE_SIZE;

}

//--------------------------------------------------

/**

 * This function returns the size of block of HASH-algorithm.

 */

EAP_FUNC_EXPORT u32_t eap_am_crypto_md4_c::get_block_size()

{

	return EAP_AM_CRYPTO_MD4_BLOCK_BYTE_SIZE;

}

//--------------------------------------------------

/**

 * This function initializes the context of MD4-algorithm.

 */

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_md4_c::hash_init()

{

	m_full_hashed_data_length = 0ul;

	m_H[0] = static_cast<u32_t>(EAP_MD4_INIT_H0);

	m_H[1] = static_cast<u32_t>(EAP_MD4_INIT_H1);

	m_H[2] = static_cast<u32_t>(EAP_MD4_INIT_H2);

	m_H[3] = static_cast<u32_t>(EAP_MD4_INIT_H3);

	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

}

//--------------------------------------------------

/**

 * This function updates the context of MD4-algorithm with data.

 */

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_md4_c::hash_update(

	const void * const data,

	const u32_t data_length)

{

	eap_status_e status = eap_status_ok;

	u32_t prosessed_data_length = 0ul;

	m_full_hashed_data_length += data_length;

	EAP_MD4_TRACE_DEBUG(m_am_tools, EAP_TRACE_MASK_MD4,

					(EAPL("MD4: Processed data length %u\n"),

					 m_full_hashed_data_length));

	if (m_saved_data.get_is_valid_data() == true

		&& m_saved_data.get_data_length() > 0ul)

	{

		// Here we have remaining data to process from previous call

		// of hash_update().

		u32_t needed_data_length = EAP_AM_CRYPTO_MD4_BLOCK_BYTE_SIZE

			- m_saved_data.get_data_length();

		if (needed_data_length > data_length)

		{

			// Not enough input data.

			needed_data_length = data_length;

		}

		prosessed_data_length = needed_data_length;

		status = m_saved_data.add_data(data, needed_data_length);

		if (status != eap_status_ok)

		{

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		if (m_saved_data.get_data_length()

			== EAP_AM_CRYPTO_MD4_BLOCK_BYTE_SIZE)

		{

			// Enough data to process.

			// Just one block of integers in W array.

			status = eap_md4_process_data(

				reinterpret_cast<const u32_t *>(

					m_saved_data.get_data(

						m_saved_data.get_data_length())),

				EAP_AM_CRYPTO_MD4_BLOCK_u32_COUNT

				);

			if (status != eap_status_ok)

			{

				return EAP_STATUS_RETURN(m_am_tools, status);

			}

			m_saved_data.reset();

		}

		EAP_ASSERT(m_saved_data.get_is_valid_data() == false

			|| m_saved_data.get_data_length()

				   <= EAP_AM_CRYPTO_MD4_BLOCK_BYTE_SIZE);