/*

* 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 22 

	#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_crypto_api.h"

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

// This is simple optimization.

const u32_t EAP_CRYPTO_API_SHA1_DIGEST_BUFFER_BYTE_SIZE = 20ul;

const u32_t EAP_CRYPTO_API_SHA1_BLOCK_BYTE_SIZE = 64ul;

const u32_t EAP_CRYPTO_API_SHA_256_DIGEST_BUFFER_BYTE_SIZE = 32ul;

const u32_t EAP_CRYPTO_API_SHA_256_BLOCK_BYTE_SIZE = 64ul;

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

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

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

EAP_FUNC_EXPORT abs_crypto_cbc_block_algorithm_c::~abs_crypto_cbc_block_algorithm_c()

{

}

EAP_FUNC_EXPORT abs_crypto_block_algorithm_c::~abs_crypto_block_algorithm_c()

{

}

EAP_FUNC_EXPORT abs_crypto_stream_algorithm_c::~abs_crypto_stream_algorithm_c()

{

}

EAP_FUNC_EXPORT abs_crypto_hash_algorithm_c::~abs_crypto_hash_algorithm_c()

{

}

EAP_FUNC_EXPORT abs_crypto_hmac_algorithm_c::~abs_crypto_hmac_algorithm_c()

{

}

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

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

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

EAP_FUNC_EXPORT crypto_hmac_c::~crypto_hmac_c()

{

	hmac_cleanup();

	delete m_key;

	m_key = 0;

	delete m_ipad;

	m_ipad = 0;

	delete m_opad;

	m_opad = 0;

}

EAP_FUNC_EXPORT crypto_hmac_c::crypto_hmac_c(

	abs_eap_am_tools_c * const tools,

	abs_crypto_hash_algorithm_c * const crypto_hash_algorithm,

	const bool free_crypto_hash_algorithm)

	: m_am_tools(tools)

	, m_crypto_hash_algorithm(crypto_hash_algorithm)

	, m_key(0)

	, m_ipad(0)

	, m_opad(0)

	, m_is_valid(false)

	, m_free_crypto_hash_algorithm(free_crypto_hash_algorithm)

{

	m_key = new eap_variable_data_c(m_am_tools);

	if (m_key == 0)

	{

		return;

	}

	m_ipad = new eap_variable_data_c(m_am_tools);

	if (m_ipad == 0)

	{

		return;

	}

	m_opad = new eap_variable_data_c(m_am_tools);

	if (m_opad == 0)

	{

		return;

	}

	set_is_valid();

}

EAP_FUNC_EXPORT void crypto_hmac_c::set_is_valid()

{

	m_is_valid = true;

}

EAP_FUNC_EXPORT bool crypto_hmac_c::get_is_valid()

{

	return m_is_valid;

}

EAP_FUNC_EXPORT u32_t crypto_hmac_c::get_digest_length()

{

	return m_crypto_hash_algorithm->get_digest_length();

}

EAP_FUNC_EXPORT eap_status_e crypto_hmac_c::initialize_pad(

	eap_variable_data_c * const p_pad,

	const u8_t pad_value)

{

	if (get_is_valid() == false)

	{

		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

	}

	eap_status_e status = p_pad->set_buffer_length(

		m_crypto_hash_algorithm->get_block_size());

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	p_pad->set_data_length(m_crypto_hash_algorithm->get_block_size());

	u32_t ind = 0ul;

	u8_t * key = m_key->get_data(m_key->get_data_length());

	u8_t * ipad = p_pad->get_data(p_pad->get_data_length());

	for (ind = 0ul; ind < m_key->get_data_length(); ind++)

	{

		ipad[ind] = static_cast<u8_t>(key[ind] ^ pad_value);

	}

	for (ind = m_key->get_data_length()

			 ; ind < m_crypto_hash_algorithm->get_block_size(); ind++)

	{

		ipad[ind] = pad_value;

	}

	return EAP_STATUS_RETURN(m_am_tools, status);

}

EAP_FUNC_EXPORT eap_status_e crypto_hmac_c::hmac_set_key(

	const eap_variable_data_c * const hmac_key)

{

	if (hmac_key == 0

		|| hmac_key->get_is_valid_data() == false

		|| get_is_valid() == false)

	{

		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

	}

	eap_status_e status = eap_status_process_general_error;

	status = m_crypto_hash_algorithm->hash_init();

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	if (hmac_key->get_data_length()

		> m_crypto_hash_algorithm->get_block_size())

	{

		status = m_crypto_hash_algorithm->hash_update(

			hmac_key->get_data(hmac_key->get_data_length()),

			hmac_key->get_data_length());

		if (status != eap_status_ok)

		{

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		status = m_key->set_buffer_length(

			m_crypto_hash_algorithm->get_digest_length());

		if (status != eap_status_ok)

		{

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		m_key->set_data_length(m_crypto_hash_algorithm->get_digest_length());

		u32_t md_length = m_key->get_data_length();

		status = m_crypto_hash_algorithm->hash_final(

			m_key->get_data(m_key->get_data_length()),

			&md_length);

		if (status != eap_status_ok)

		{

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		EAP_ASSERT(md_length == m_key->get_data_length());

	}

	else

	{

		status = m_key->set_copy_of_buffer(hmac_key);

		if (status != eap_status_ok)

		{

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

	}

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

	// Initialize inner pad.

	{

		static const u8_t EAP_HMAC_IPAD = 0x36;

		status = initialize_pad(

			m_ipad,

			EAP_HMAC_IPAD);

		if (status != eap_status_ok)

		{

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

	}

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

	// Initialize outer pad.

	{

		static const u8_t EAP_HMAC_OPAD = 0x5C;

		status = initialize_pad(

			m_opad,

			EAP_HMAC_OPAD);

		if (status != eap_status_ok)

		{

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

	}

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

	status = m_crypto_hash_algorithm->hash_init();

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	status = m_crypto_hash_algorithm->hash_update(

		m_ipad->get_data(m_ipad->get_data_length()),

		m_ipad->get_data_length());

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	return EAP_STATUS_RETURN(m_am_tools, status);

}

EAP_FUNC_EXPORT eap_status_e crypto_hmac_c::hmac_update(

	const void * const data,

	const u32_t data_length)

{

	if (get_is_valid() == false)

	{

		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

	}

	eap_status_e status = m_crypto_hash_algorithm->hash_update(

		data,

		data_length);

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	return EAP_STATUS_RETURN(m_am_tools, status);

}

EAP_FUNC_EXPORT eap_status_e crypto_hmac_c::hmac_final(

	void * const message_digest,

	u32_t *md_length_or_null)

{

	if (get_is_valid() == false)

	{

		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

	}

	eap_variable_data_c idigest(m_am_tools);

	eap_status_e status = idigest.set_buffer_length(

		m_crypto_hash_algorithm->get_digest_length());

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	idigest.set_data_length(m_crypto_hash_algorithm->get_digest_length());

	u32_t md_length = idigest.get_data_length();

	status = m_crypto_hash_algorithm->hash_final(

		idigest.get_data(idigest.get_data_length()),

		&md_length);

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	EAP_ASSERT(md_length == m_crypto_hash_algorithm->get_digest_length());

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

	status = m_crypto_hash_algorithm->hash_init();

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	status = m_crypto_hash_algorithm->hash_update(

		m_opad->get_data(m_opad->get_data_length()),

		m_opad->get_data_length());

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	status = m_crypto_hash_algorithm->hash_update(

		idigest.get_data(idigest.get_data_length()),

		idigest.get_data_length());

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	status = m_crypto_hash_algorithm->hash_final(

		message_digest,

		md_length_or_null);

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	if (md_length_or_null != 0)

	{

		EAP_ASSERT(*md_length_or_null

				   == m_crypto_hash_algorithm->get_digest_length());

	}

	return EAP_STATUS_RETURN(m_am_tools, status);

}

EAP_FUNC_EXPORT eap_status_e crypto_hmac_c::hmac_128_final(

	void * const message_digest,

	u32_t *md_length_or_null)

{

	if (message_digest == 0)

	{

		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

	}

	u32_t tmp_length = get_digest_length();

	eap_variable_data_c tmp_digest(m_am_tools);

	if (tmp_digest.get_is_valid() == false)

	{

		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

	}

	eap_status_e status = tmp_digest.set_buffer_length(tmp_length);

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	status = hmac_final(

		tmp_digest.get_buffer(tmp_digest.get_buffer_length()),

		&tmp_length);

	if (status != eap_status_ok

		|| tmp_length != tmp_digest.get_buffer_length())

	{

		if (md_length_or_null != 0)

		{

			*md_length_or_null = 0;

		}

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	else

	{

		status = tmp_digest.set_data_length(tmp_length);

		if (status != eap_status_ok)

	    {

			return EAP_STATUS_RETURN(m_am_tools, status);

	    }

		if (md_length_or_null != 0)

		{

			*md_length_or_null = HMAC_SHA1_128_SIZE;

		}

		m_am_tools->memmove(

			message_digest,

			tmp_digest.get_data(HMAC_SHA1_128_SIZE),

			HMAC_SHA1_128_SIZE);

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

}

EAP_FUNC_EXPORT eap_status_e crypto_hmac_c::hmac_cleanup()

{

	if (m_key != 0)

	{

		m_key->reset();

	}

	if (m_ipad != 0)

	{

		m_ipad->reset();

	}

	if (m_opad != 0)

	{

		m_opad->reset();

	}

	if (m_free_crypto_hash_algorithm == true)

	{

		delete m_crypto_hash_algorithm;

	}

	m_crypto_hash_algorithm = 0;

	m_is_valid = false;

	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

}

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

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

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

EAP_FUNC_EXPORT crypto_cbc_c::~crypto_cbc_c()

{

	reset();

}

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

EAP_FUNC_EXPORT crypto_cbc_c::crypto_cbc_c(

	abs_eap_am_tools_c * const tools,

	abs_crypto_block_algorithm_c * const crypto_block_algorithm,

	const bool free_crypto_block_algorithm)

	: m_am_tools(tools)

	, m_crypto_block_algorithm(crypto_block_algorithm)

	, m_is_valid(false)

	, m_tmp_IV(0)

	, m_encr_offset(0ul)

	, m_encr_dispatch(0)

	, m_encr_hold(0)

	, m_saved_in_buffer(0)

	, m_saved_out_buffer(0)

	, m_iv_buffer_1(0)

	, m_iv_buffer_2(0)

	, m_free_crypto_block_algorithm(free_crypto_block_algorithm)

{

	m_tmp_IV = new eap_variable_data_c(m_am_tools);

	m_encr_dispatch = new u8_t *[m_crypto_block_algorithm->get_block_size()];

	m_encr_hold = new u8_t [m_crypto_block_algorithm->get_block_size()];

	m_saved_in_buffer = new u8_t [m_crypto_block_algorithm->get_block_size()];

	m_saved_out_buffer = new u8_t [m_crypto_block_algorithm->get_block_size()];

	m_iv_buffer_1 = new u8_t [m_crypto_block_algorithm->get_block_size()];

	m_iv_buffer_2 = new u8_t [m_crypto_block_algorithm->get_block_size()];

	if (m_tmp_IV == 0

		|| m_encr_dispatch == 0

		|| m_encr_hold == 0

		|| m_saved_in_buffer == 0

		|| m_saved_out_buffer == 0

		|| m_iv_buffer_1 == 0

		|| m_iv_buffer_2 == 0)

	{

		reset();

	}

	else

	{

		set_is_valid();

	}

}

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

EAP_FUNC_EXPORT void crypto_cbc_c::reset()

{

	m_is_valid = false;

	if (m_tmp_IV != 0)

	{

		m_tmp_IV->reset();

		delete m_tmp_IV;

		m_tmp_IV = 0;

	}

	if (m_crypto_block_algorithm != 0)

	{

		if (m_encr_dispatch != 0)

		{

			m_am_tools->memset(

				m_encr_dispatch,

				0,

				m_crypto_block_algorithm->get_block_size());

		}

		if (m_encr_hold != 0)

		{

			m_am_tools->memset(