/*

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

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

#include "eap_crypto_api.h"

#include "eapol_key_header.h"

#include "eapol_rc4_key_header.h"

#include "eap_state_notification.h"

#include "eap_automatic_variable.h"

#include "eap_network_id_selector.h"

#include "eap_config.h"

#include "eap_buffer.h"

#include "eapol_session_key.h"

#include "eap_master_session_key.h"

#define MPPE_KEY_LENGTH 32

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

// 

EAP_FUNC_EXPORT eapol_core_c::~eapol_core_c()

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(

		m_am_tools, 

		TRACE_FLAGS_DEFAULT, 

		(EAPL("eapol_core_c::~eapol_core_c(): this = 0x%08x\n"),

		this));

	EAP_ASSERT(m_shutdown_was_called == true);

	delete m_eap_core;

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

}

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

#if defined(_WIN32) && !defined(__GNUC__)

	#pragma warning( disable : 4355 ) // 'this' : used in base member initializer list

#endif

// 

EAP_FUNC_EXPORT eapol_core_c::eapol_core_c(

	abs_eap_am_tools_c * const tools,

	abs_eapol_core_c * const partner,

	const bool is_client_when_true)

	: m_partner(partner)

#if !defined(NO_EAP_SESSION_CORE)

	  , m_eap_core(new eap_session_core_c(tools, this, is_client_when_true))

#else

	  , m_eap_core(new eap_core_c(tools, this, is_client_when_true, 0, false))

#endif

#if defined(USE_EAPOL_KEY_STATE)

	  , m_eapol_key_state_map(tools, this)

#endif //#if defined(USE_EAPOL_KEY_STATE)

	  , m_am_tools(tools)

	  , m_master_session_key(m_am_tools)

	  , m_authentication_type(eapol_key_authentication_type_none)

	  , m_eapol_header_offset(0u)

	  , m_MTU(0u)

	  , m_trailer_length(0u)

	  , m_max_eapol_starts(0u)

	  , m_eapol_start_interval(0u)

	  , m_eapol_starts_sent(0u)

	  , m_is_client(is_client_when_true)

	  , m_is_valid(false)

	  , m_shutdown_was_called(false)

	  , m_block_state_notifications(false)

#if defined(USE_EAPOL_KEY_STATE)

	  , m_skip_start_4_way_handshake(false)

#endif //#if defined(USE_EAPOL_KEY_STATE)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(

		m_am_tools, 

		TRACE_FLAGS_DEFAULT, 

		(EAPL("eapol_core_c::eapol_core_c(): %s, this = 0x%08x => 0x%08x, compiled %s %s.\n"),

		(m_is_client == true) ? "client": "server",

		this,

		dynamic_cast<abs_eap_base_timer_c *>(this),

		__DATE__,

		__TIME__));

	if (m_eap_core != 0

		&& m_eap_core->get_is_valid() == true)

	{

		set_is_valid();

	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

}

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

//

EAP_FUNC_EXPORT eap_status_e eapol_core_c::packet_process(

	const eap_am_network_id_c * const receive_network_id,

	eap_general_header_base_c * const packet_data,

	const u32_t packet_length)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	eap_status_e status = eap_status_process_general_error;

	if (receive_network_id == 0

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

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

	}

	if (packet_data == 0

		|| packet_length < eap_header_base_c::get_header_length())

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_illegal_packet_error);

	}

	eapol_header_wr_c eapol(

		m_am_tools,

		packet_data->get_header_buffer(packet_data->get_header_buffer_length()),

		packet_data->get_header_buffer_length());

	if (eapol.get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_illegal_packet_error);

	}

	if (packet_length < eapol.get_data_length())

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_illegal_packet_error);

	}

	if (m_eap_core == 0)

	{

		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

	}

	if (packet_length < eapol_header_rd_c::get_header_length() // First we need atleast header to check the data length.

		|| packet_length < eapol_header_rd_c::get_header_length()+eapol.get_data_length())

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_illegal_packet_error);

	}

	EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("-> EAPOL: %s, version=0x%02x, packet_type=0x%02x=%s, data_length=0x%04x, packet_length 0x%04x\n"),

		(m_is_client == true) ? "client": "server",

		eapol.get_version(),

		eapol.get_packet_type(),

		eapol.get_type_string(),

		eapol.get_data_length(),

		packet_length));

	status = eapol.check_header();

	if (status != eap_status_ok)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	if (receive_network_id->get_type() == eapol_ethernet_type_preauthentication

		&& eapol.get_packet_type() != eapol_packet_type_eap

		&& eapol.get_packet_type() != eapol_packet_type_start)

	{

		// Only EAP-Packet and EAPOL-Start are valid for preauthentication.

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_wrong_eapol_type);

	}

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

	eapol_key_state_c *eapol_key_state = 0;

	{

		// Here we swap the addresses.

		eap_am_network_id_c send_network_id(

			m_am_tools,

			receive_network_id->get_destination_id(),

			receive_network_id->get_source_id(),

			receive_network_id->get_type());

		if (send_network_id.get_is_valid_data() == false)

		{

			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

		}

		eap_network_id_selector_c state_selector(

			m_am_tools,

			&send_network_id);

		if (state_selector.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_TRACE_DATA_DEBUG(

			m_am_tools,

			TRACE_FLAGS_DEFAULT,

			(EAPL("packet_process(): EAPOL-Key session"),

			state_selector.get_data(state_selector.get_data_length()),

			state_selector.get_data_length()));

		// Check do we have handler for this packet. This applies to EAP-packets too.

		eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

		if (eapol_key_state == 0)

		{

			EAP_TRACE_DEBUG(

				m_am_tools, 

				TRACE_FLAGS_DEFAULT, 

				(EAPL("ERROR: eapol_core_c::packet_process() failed, no eapol_key_state_c object for this packet. Drop packet.\n")));

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_drop_packet_quietly);

		}

	}

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

	if (eapol.get_packet_type() == eapol_packet_type_eap

		&& eapol.get_data_length() >= eap_header_base_c::get_header_length())

	{

		if (m_authentication_type != eapol_key_authentication_type_RSNA_EAP

			&& m_authentication_type != eapol_key_authentication_type_WPA_EAP

#if defined(EAP_USE_WPXM)

			&& m_authentication_type != eapol_key_authentication_type_WPXM

#endif //#if defined(EAP_USE_WPXM)

			&& m_authentication_type != eapol_key_authentication_type_WFA_SC

			)

		{

			EAP_TRACE_DEBUG(

				m_am_tools, 

				TRACE_FLAGS_DEFAULT, 

				(EAPL("WARNING: eapol_core_c::packet_process(): Illegal authentication type 0x%08x\n"),

				 m_authentication_type));

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_wrong_eapol_type);

		}

#if defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)

		// Test first we are connected.

		if (eapol_key_state->get_is_associated() == true)

		{

			status = m_eap_core->synchronous_create_eap_session(receive_network_id);

			if (status != eap_status_ok)

			{

				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

				return EAP_STATUS_RETURN(m_am_tools, status);

			}

		}

#endif //#if !defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)

		eap_header_wr_c eap(

			m_am_tools,

			eapol.get_eap_header(),

			eapol.get_data_length());

		status = m_eap_core->packet_process(

			receive_network_id,

			&eap,

			eapol.get_data_length());

		EAP_GENERAL_HEADER_COPY_ERROR_PARAMETERS(packet_data, &eap);

	}

	else if (m_is_client == false

		&& eapol.get_packet_type() == eapol_packet_type_logoff)

	{

		status = eap_status_ok;

	}

	else if (m_is_client == false

		&& eapol.get_packet_type() == eapol_packet_type_start)

	{

		if (m_authentication_type != eapol_key_authentication_type_RSNA_EAP

			&& m_authentication_type != eapol_key_authentication_type_WPA_EAP

			&& m_authentication_type != eapol_key_authentication_type_WFA_SC

#if defined(EAP_USE_WPXM)

			&& m_authentication_type != eapol_key_authentication_type_WPXM

#endif //#if defined(EAP_USE_WPXM)

			)

		{

			EAP_TRACE_DEBUG(

				m_am_tools, 

				TRACE_FLAGS_DEFAULT, 

				(EAPL("WARNING: eapol_core_c::packet_process(): Illegal authentication type 0x%08x\n"),

				 m_authentication_type));

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_wrong_eapol_type);

		}

		// This call does not cause clean restart. On-going authentication is not terminated.

		status = restart_authentication(

			receive_network_id,

			m_is_client,

			false);

	}

#if defined(USE_EAPOL_KEY_STATE)

	else if (eapol.get_packet_type() == eapol_packet_type_key)

	{

		if (m_authentication_type != eapol_key_authentication_type_RSNA_EAP

			&& m_authentication_type != eapol_key_authentication_type_RSNA_PSK

			&& m_authentication_type != eapol_key_authentication_type_WPA_EAP

			&& m_authentication_type != eapol_key_authentication_type_WPA_PSK

#if defined(EAP_USE_WPXM)

			&& m_authentication_type != eapol_key_authentication_type_WPXM

#endif //#if defined(EAP_USE_WPXM)

			)

		{

			EAP_TRACE_DEBUG(

				m_am_tools, 

				TRACE_FLAGS_DEFAULT, 

				(EAPL("WARNING: eapol_core_c::packet_process(): Illegal authentication type 0x%08x\n"),

				 m_authentication_type));

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_wrong_eapol_type);

		}

		// Indicates EAP-Core of received EAPOL-Key message.

		// This is indication of finished EAP-authentication.

		// NOTE, we do not care of the status.

		// Some EAP-types does not implement this function.

		(void) eap_acknowledge(receive_network_id);

		if (eapol_key_state != 0)

		{

			status = eapol_key_state->process_eapol_key_frame(

				receive_network_id,

				packet_data,

				packet_length);

		}

		else

		{

			EAP_TRACE_DEBUG(

				m_am_tools, 

				TRACE_FLAGS_DEFAULT, 

				(EAPL("ERROR: process_eapol_key_frame() failed, no eapol_key_state_c object\n")));

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_handler_does_not_exists_error);

		}

	}

#endif //#if defined(USE_EAPOL_KEY_STATE)

#if ! defined(USE_EAPOL_KEY_STATE)

	else if (

		m_is_client == true

		&& eapol.get_packet_type() == eapol_packet_type_key)

	{

		// Handle EAPOL-Key frame.

		// Here is assumed the EAPOL-Key frame includes RC4 Key Descriptor.

		/**

		 * @{ Here we need to check the Descriptor Type field.

		 * It may be RC4 Key Descriptor, RSNA Key Descriptor or other descriptor. }

		 */

		eapol_RC4_key_header_c eapol_key_msg(

			m_am_tools,

			eapol.get_header_buffer(eapol.get_header_buffer_length()),

			eapol.get_header_buffer_length());

		if (eapol_key_msg.get_is_valid() == false)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_header_corrupted);

		}

		else if (eapol_key_msg.check_header() != eap_status_ok)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		status = handle_RC4_key_descriptor(

			receive_network_id,

			&eapol_key_msg,

			packet_length);

	}

#endif //#if ! defined(USE_EAPOL_KEY_STATE)

	else

	{

		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("ERROR: %s, packet_type=0x%02x=%s not handled, data length 0x%04x.\n"),

			(m_is_client == true) ? "client": "server",

			eapol.get_packet_type(),

			eapol.get_type_string(),

			eapol.get_data_length()));

		EAP_TRACE_DATA_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("     source"), receive_network_id->get_source(), receive_network_id->get_source_length()));

		EAP_TRACE_DATA_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("destination"), receive_network_id->get_destination(), receive_network_id->get_destination_length()));

		status = eap_status_wrong_eapol_type;

	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

	return EAP_STATUS_RETURN(m_am_tools, status);

}

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

//

EAP_FUNC_EXPORT eap_status_e eapol_core_c::packet_send(

	const eap_am_network_id_c * const send_network_id,

	eap_buf_chain_wr_c * const sent_packet,

	const u32_t header_offset,

	const u32_t data_length,

	const u32_t buffer_length)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	EAP_ASSERT(header_offset < sent_packet->get_data_length());

	EAP_ASSERT(data_length <= sent_packet->get_data_length());

	EAP_ASSERT(sent_packet->get_data_length() <= buffer_length);

	if (header_offset < eap_header_wr_c::get_header_length())

	{

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

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

	}

	eapol_header_wr_c eapol(

		m_am_tools,

		sent_packet->get_data_offset(

			header_offset-eap_header_wr_c::get_header_length(), data_length),

		data_length);

	if (eapol.get_is_valid() == false)

	{

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

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_header_corrupted);

	}

	eapol.set_version(eapol_protocol_version_1);

	eapol.set_packet_type(eapol_packet_type_eap);

	eapol.set_data_length(static_cast<u16_t>(data_length));

	{

		eap_network_id_selector_c state_selector(

			m_am_tools,

			send_network_id);

		if (state_selector.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_TRACE_DATA_DEBUG(

			m_am_tools,

			TRACE_FLAGS_DEFAULT,

			(EAPL("packet_send(): EAPOL-Key session"),

			state_selector.get_data(state_selector.get_data_length()),

			state_selector.get_data_length()));

		eapol_key_state_c *session = m_eapol_key_state_map.get_handler(&state_selector);

		bool encryption_on(false);

		if (session != 0

			&& session->get_is_valid() == true)

		{

			encryption_on = session->get_is_encryption_on();

		}

		EAP_TRACE_DEBUG(

			m_am_tools,

			TRACE_FLAGS_DEFAULT,

			(EAPL("Read EAPOL-Key session: encryption is %s\n"),

			((encryption_on == true) ? "on" : "off")));

		sent_packet->set_encrypt(encryption_on);

	}

	EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("<- EAPOL: %s, version=0x%02x, packet_type=0x%02x=%s, data_length=0x%04x, packet_length 0x%04x\n"),

		(m_is_client == true) ? "client": "server",

		eapol.get_version(),

		eapol.get_packet_type(),

		eapol.get_type_string(),

		eapol.get_data_length(),

		data_length));