/*

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

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

#include "eap_type_aka.h"

#include "eap_type_aka_header.h"

#include "eap_type_aka_payloads.h"

#include "abs_eap_am_type_aka.h"

#include "eap_crypto_api.h"

#include "eap_state_notification.h"

#include "eap_automatic_variable.h"

#include "eap_buffer.h"

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

/** @file */

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

//

EAP_FUNC_EXPORT eap_status_e eap_type_aka_c::add_mac_payload(

	aka_header_c * const aka,

	const u32_t aka_buffer_length,

	const u32_t eap_header_size,

	u32_t * const aka_data_offset,

	u32_t * const aka_data_free,

	u32_t * const packet_buffer_free,

	u32_t * const packet_buffer_offset,

	u8_t ** const MAC_data,

	u32_t * const MAC_data_length)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	aka_payload_AT_header_c gp_MAC(

		m_am_tools,

		aka->get_data_offset(

			*aka_data_offset, *aka_data_free),

		*aka_data_free);

	if (gp_MAC.get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_header_corrupted);

	}

	u32_t eap_type_aka_mac_size = EAP_TYPE_AKA_MAC_SIZE;

	gp_MAC.reset_header(static_cast<u16_t>(eap_type_aka_mac_size));

	gp_MAC.set_data_length(static_cast<u16_t>(eap_type_aka_mac_size));

	gp_MAC.set_current_payload(aka_payload_AT_MAC);

	*MAC_data = gp_MAC.get_data(eap_type_aka_mac_size);

	if (*MAC_data == 0)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

	}

	*MAC_data_length = eap_type_aka_mac_size;

	m_am_tools->memset(*MAC_data, 0, eap_type_aka_mac_size);

	// MAC is calculated later using call create_message_authentication_code().

	update_payload_indexes(

		aka_buffer_length,

		eap_header_size,

		gp_MAC.get_header_length()+gp_MAC.get_data_length(),

		aka_data_offset,

		aka_data_free,

		packet_buffer_offset,

		packet_buffer_free);

	EAP_AKA_TRACE_PAYLOAD("Payload added", &gp_MAC);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

}

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

//

EAP_FUNC_EXPORT eap_status_e eap_type_aka_c::add_padding_payload(

	aka_header_c * const aka,

	const u32_t aka_buffer_length,

	const u32_t eap_header_size,

	u32_t * const aka_data_offset,

	u32_t * const aka_data_free,

	u32_t * const packet_buffer_free,

	u32_t * const packet_buffer_offset,

	const u32_t plaintext_length)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	aka_payload_AT_header_c gp_padding(

		m_am_tools,

		aka->get_data_offset(

			*aka_data_offset, *aka_data_free),

		*aka_data_free);

	if (gp_padding.get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_header_corrupted);

	}

	crypto_aes_c aes(m_am_tools);

	crypto_cbc_c cbc_aes(m_am_tools, &aes, false);

	if (cbc_aes.get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

	}

	if ((plaintext_length % cbc_aes.get_block_size()) == 0ul)

	{

		// We do not need padding, because plaintext length is multiple of

		// block size.

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

	}

	u32_t cbc_aes_data_length = cbc_aes.aligned_data_length(plaintext_length);

	u32_t padding_bytes_length = 0u;

	if (cbc_aes_data_length

		> plaintext_length+aka_payload_AT_header_c::get_header_length())

	{

		// Fill with zero (0x00) bytes.

		padding_bytes_length

			= cbc_aes_data_length

			- (plaintext_length

			   +aka_payload_AT_header_c::get_header_length());

	}

	u32_t padding_payload_length

		= aka_payload_AT_header_c::get_header_length()

		+padding_bytes_length;

	if ((padding_payload_length % EAP_TYPE_AKA_PADDING_MODULUS) != 0)

	{

		// ERROR

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_padding);

	}

	if (padding_payload_length > EAP_TYPE_AKA_PADDING_MAX_VALUE)

	{

		padding_payload_length = 0ul;

		padding_bytes_length = 0ul;

	}

	// Note the reserved field is the begin of padding.

	// The reserved field is set zero in reset_header() function.

	gp_padding.reset_header(static_cast<u16_t>(padding_payload_length));

	gp_padding.set_data_length(static_cast<u16_t>(padding_bytes_length));

	gp_padding.set_current_payload(aka_payload_AT_PADDING);

	if (padding_bytes_length > 0ul)

	{

		u8_t *padding = gp_padding.get_data(padding_bytes_length);

		if (padding == 0)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

		}

		cbc_aes.add_padding_bytes(

			padding,

			padding_bytes_length,

			0ul);

	}

	update_payload_indexes(

		aka_buffer_length,

		eap_header_size,

		gp_padding.get_header_length()+gp_padding.get_data_length(),

		aka_data_offset,

		aka_data_free,

		packet_buffer_offset,

		packet_buffer_free);

	EAP_AKA_TRACE_PAYLOAD("Padding payload added", &gp_padding);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

}

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

//

EAP_FUNC_EXPORT eap_status_e eap_type_aka_c::encrypt_DATA_payload(

	u8_t * const data,

	const u32_t cbc_aes_data_length,

	const eap_variable_data_c * const IV,

	const eap_variable_data_c * const encryption_key

	)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	eap_status_e status = eap_status_process_general_error;

	if (data == 0

		|| cbc_aes_data_length == 0

		|| IV == 0

		|| IV->get_is_valid_data() == false

		|| encryption_key == 0

		|| encryption_key->get_is_valid_data() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

	}

	crypto_aes_c aes(m_am_tools);

	crypto_cbc_c cbc_aes(m_am_tools, &aes, false);

	if (cbc_aes.get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

	}

	u32_t aes_key_length = aes.get_key_length();

	if (encryption_key->get_data_length() < aes_key_length)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_key_error);

	}

	status = cbc_aes.set_encryption_key(

		IV->get_data(IV->get_data_length()),

		IV->get_data_length(),

		encryption_key->get_data(encryption_key->get_data_length()),

		aes_key_length);

	if (status != eap_status_ok)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	status = cbc_aes.encrypt_data(

		data,

		cbc_aes_data_length);

	store_last_encryption_iv(cbc_aes.get_tmp_IV());

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

	return EAP_STATUS_RETURN(m_am_tools, status);

}

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

//

EAP_FUNC_EXPORT eap_status_e eap_type_aka_c::send_reauthentication_request_message(

	const eap_variable_data_c * const username,

	const bool pseudonym_decode_failed,

	const u8_t eap_identifier)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_UNREFERENCED_PARAMETER(pseudonym_decode_failed);

	EAP_TRACE_DEBUG(

		m_am_tools, 

		TRACE_FLAGS_DEFAULT, 

		(EAPL("    send: handler 0x%08x, AKA-subtype %10s, %s, state %2d=%s\n"),

		 this,

		 EAPL("aka_subtype_Re_authentication"),

		 EAPL("server"),

		 get_state(),

		 get_state_string()

		 ));

	eap_variable_data_c checkcode_digest(m_am_tools);

	if (checkcode_digest.get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

	}

	eap_status_e status = eap_status_process_general_error;

	status = checkcode_final(

		&checkcode_digest);

	if (status != eap_status_ok)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	eap_buf_chain_wr_c request_packet(

		eap_write_buffer, 

		m_am_tools, 

		EAP_MAX_LOCAL_PACKET_BUFFER_LENGTH);

	if (request_packet.get_is_valid() == false)

	{

		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("packet buffer corrupted.\n")));

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

	}

	if (m_is_client == true

		&& m_client_responds_retransmitted_packets == true)

	{

		// We do not wan't lower layers do re-transmissions behalf of us.

		// This means AKA does process every re-transmitted EAP-Request.

		request_packet.set_do_packet_retransmission(false);

	}

	EAP_ASSERT_ALWAYS(EAP_TYPE_AKA_LOCAL_PACKET_BUFFER_LENGTH >= (m_aka_header_offset+m_trailer_length));

	u32_t packet_buffer_free = EAP_TYPE_AKA_LOCAL_PACKET_BUFFER_LENGTH-m_trailer_length;

	u32_t packet_buffer_offset = 0u;

	if (m_aka_header_offset+m_MTU < packet_buffer_free)

	{

		packet_buffer_free = m_aka_header_offset+m_MTU;

	}

	aka_header_c aka_response(

		m_am_tools,

		request_packet.get_data_offset(

			m_aka_header_offset,

			(packet_buffer_free-m_aka_header_offset)),

		(packet_buffer_free-m_aka_header_offset));

	if (aka_response.get_is_valid() == false)

	{

		EAP_TRACE_DEBUG(

			m_am_tools,

			TRACE_FLAGS_DEFAULT,

			(EAPL("send_reauthentication_request_message: packet buffer corrupted.\n")));

		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

	}

	aka_response.reset_header(

		packet_buffer_free-m_aka_header_offset,

		m_use_eap_expanded_type);

	aka_response.set_length(

		static_cast<u16_t>(packet_buffer_free-m_aka_header_offset),

		m_use_eap_expanded_type);

	aka_response.set_code(eap_code_request);

	aka_response.set_identifier(eap_identifier);

	aka_response.set_type(

		eap_type_aka,

		m_use_eap_expanded_type);

	aka_response.set_subtype(aka_subtype_Re_authentication);

	update_buffer_indexes(

		EAP_TYPE_AKA_LOCAL_PACKET_BUFFER_LENGTH,

		m_aka_header_offset+aka_response.get_header_length(),

		&packet_buffer_offset,

		&packet_buffer_free);

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

	EAP_TRACE_DEBUG(

		m_am_tools, 

		TRACE_FLAGS_DEFAULT, 

		(EAPL("eap_type_aka_c::send_reauthentication_request_message(0x%08x).\n"),

		this));

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

	u32_t aka_data_free = packet_buffer_free;

	u32_t aka_data_offset = 0u;

	eap_variable_data_c orig_XKEY(m_am_tools);

	eap_variable_data_c orig_K_aut(m_am_tools);

	eap_variable_data_c orig_K_encr(m_am_tools);

	if (orig_XKEY.get_is_valid() == false

		|| orig_K_aut.get_is_valid() == false

		|| orig_K_encr.get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

	}

	u32_t reauth_counter = 0u;

	eap_variable_data_c reauth_nonce_s(m_am_tools);

	if (reauth_nonce_s.get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

	}

	// In order to use re-authentication, the client and the server need to

	// store the following values: original XKEY, K_aut, K_encr, latest

	// counter value and the next re-authentication identity.

	status = m_am_type_aka->query_reauth_parameters(

		&orig_XKEY,

		&orig_K_aut,

		&orig_K_encr,

		&reauth_counter);

	if (status != eap_status_ok)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	status = generate_nonce(EAP_TYPE_AKA_NONCE_MT_SIZE, &reauth_nonce_s);

	if (status != eap_status_ok)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	status = get_NONCE_S()->set_copy_of_buffer(&reauth_nonce_s);

	if (status != eap_status_ok)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	eap_variable_data_c master_session_key(m_am_tools);

	if (master_session_key.get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

	}

	status = generate_reauth_shared_secred_keys(

		EAP_TYPE_AKA_KEYMAT_SIZE,

		&orig_XKEY,

		reauth_counter,

		username,

		&reauth_nonce_s,

		&master_session_key);

	if (status != eap_status_ok)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

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

	m_use_result_indication = m_allow_use_result_indication;

	if (m_use_result_indication == true)

	{

		// We support use of protected success indications.

		status = add_simple_payload(

			&aka_response,

			EAP_TYPE_AKA_LOCAL_PACKET_BUFFER_LENGTH,

			aka_response.get_header_length(),

			&aka_data_offset,

			&aka_data_free,

			&packet_buffer_free,

			&packet_buffer_offset,

			aka_payload_AT_RESULT_IND);

		if (status != eap_status_ok)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

	}

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

	status = add_variable_payload(

		&aka_response,

		EAP_TYPE_AKA_LOCAL_PACKET_BUFFER_LENGTH,

		aka_response.get_header_length(),

		&aka_data_offset,

		&aka_data_free,

		&packet_buffer_free,

		&packet_buffer_offset,

		&checkcode_digest,

		aka_payload_AT_CHECKCODE);

	if (status != eap_status_ok)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

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

	crypto_aes_c aes(m_am_tools);

	if (aes.get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

	}

	status = m_am_type_aka->generate_encryption_IV(

		get_IV()->get_payload_buffer(),

		aes.get_block_size());

	if (status != eap_status_ok)