/*

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

	#undef EAP_FILE_NUMBER_DATE 

	#define EAP_FILE_NUMBER_DATE 1127594498 

#endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

// INCLUDES

#include <hash.h>

#include <random.h>

#include <asymmetric.h>

#include <symmetric.h>

#include <rijndael.h>

#include <x509keys.h>

#include <asn1dec.h>

#include <asn1enc.h>

#include "eap_am_crypto_symbian.h"

#include "eap_tools.h"

#include "eap_am_tools_symbian.h"

#include "dss_random.h"

#include "eap_am_crypto_sha_256.h"

#include "eap_am_crypto_sha1.h"

#include "eap_am_crypto_rc4.h"

#include "eap_am_crypto_md4.h"

#include "eap_am_memory.h"

#include "eap_am_assert.h"

// LOCAL DATA

const u32_t BLOCK_SIZE_3DES_EDE = 8ul;

const u32_t MD5_BLOCK_SIZE = 64ul;

const u32_t AES_KEY_SIZE = 16ul;

const u32_t AES_BLOCK_SIZE = 16ul;

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

//

EAP_FUNC_EXPORT eap_am_crypto_symbian_c::~eap_am_crypto_symbian_c()

{

}

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

//

EAP_FUNC_EXPORT eap_am_crypto_symbian_c::eap_am_crypto_symbian_c(abs_eap_am_tools_c * const tools)

	: m_am_tools(tools)

	, m_is_valid(false)

{

	m_is_valid = true;

}

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

//

EAP_FUNC_EXPORT bool eap_am_crypto_symbian_c::get_is_valid() const

{

	return m_is_valid;

}

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

//

EAP_FUNC_EXPORT void eap_am_crypto_symbian_c::set_is_valid()

{

	m_is_valid = true;

}

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

//

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_symbian_c::configure()

{

	return eap_status_ok;

}

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

//

EAP_FUNC_EXPORT void eap_am_crypto_symbian_c::use_test_random(

	const u8_t * const /* seed */,

	const u32_t /* seed_length */,

	const bool /* does_continuous_seeding_when_true */)

{

	// This does nothing yet. Later we may need test random generator.

}

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

//

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_symbian_c::add_rand_seed(

	const u8_t * const /* bytes */, const u32_t /* length */)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);	

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	return eap_status_ok;

}

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

//

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_symbian_c::add_rand_seed_hw_ticks()

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	u64_t ticks = m_am_tools->get_hardware_ticks();

	u8_t entropy_bits = static_cast<u8_t>(ticks & 0xff);

	add_rand_seed(

		reinterpret_cast<u8_t *>(&entropy_bits),

		sizeof(entropy_bits));

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	return eap_status_ok;

}

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

//

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_symbian_c::get_rand_bytes(

	u8_t * const bytes,

	const u32_t length)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	TPtr8 target(bytes, length, length);

	TRandom::Random(target);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	return eap_status_ok;

}

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_symbian_c::generate_diffie_hellman_keys(

	eap_variable_data_c * const own_private_dh_key,

	eap_variable_data_c * const own_public_dh_key,

	const u8_t * const prime,

	const u32_t prime_length,

	const u8_t * const group_generator,

	const u32_t group_generator_length)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);	

	eap_status_e status = eap_status_ok;

	TRAPD(err, generate_diffie_hellman_keysL(

		own_private_dh_key,

		own_public_dh_key,

		prime,

		prime_length,

		group_generator,

		group_generator_length));

	if (err != KErrNone)

	{

		status = ((m_am_tools)->convert_am_error_to_eapol_error(err));

	} 

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	return EAP_STATUS_RETURN(m_am_tools, status);

}

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

void eap_am_crypto_symbian_c::generate_diffie_hellman_keysL(

	eap_variable_data_c * const own_private_dh_key,

	eap_variable_data_c * const own_public_dh_key,

	const u8_t * const prime,

	const u32_t prime_length,

	const u8_t * const group_generator,

	const u32_t group_generator_length)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	eap_status_e status;

	TPtrC8 _prime(prime, prime_length);

	TPtrC8 _generator(group_generator, group_generator_length);

	RInteger N = RInteger::NewL(_prime);

	CleanupStack::PushL(N);

	RInteger G = RInteger::NewL(_generator);

	CleanupStack::PushL(G);	

	CDHKeyPair* dh_key = CDHKeyPair::NewL(N, G);

	CleanupStack::Pop(&G); // N, G

	CleanupStack::Pop(&N); // N, G

	CleanupStack::PushL(dh_key);

	const CDHPublicKey& publicKey = dh_key->PublicKey();

	const TInteger& X = publicKey.X();

	HBufC8* p = X.BufferLC();

	// Copy the public key

	status = own_public_dh_key->set_copy_of_buffer(p->Des().Ptr(), p->Length());

	if (status != eap_status_ok)

	{

		User::Leave(KErrNoMemory);

	}

	CleanupStack::PopAndDestroy(p); 

	const CDHPrivateKey& privateKey = dh_key->PrivateKey();

	const TInteger& x = privateKey.x();

	p = x.BufferLC();

	// Copy the private key

	status = own_private_dh_key->set_copy_of_buffer(p->Des().Ptr(), p->Length());

	if (status != eap_status_ok)

	{

		User::Leave(KErrNoMemory);

	}

	CleanupStack::PopAndDestroy(p); 

	CleanupStack::PopAndDestroy(dh_key);			

	EAP_TRACE_DATA_DEBUG(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO, (EAPL("own_public_dh_key"),

		own_public_dh_key->get_data(own_public_dh_key->get_data_length()),

		own_public_dh_key->get_data_length()));

	EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO, (EAPL("own_private_dh_key is hidden in Symbian.\n")));

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

}

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

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_symbian_c::generate_g_power_to_xy(

	const eap_variable_data_c * const own_private_dh_key,

	const eap_variable_data_c * const peer_public_dh_key,

	eap_variable_data_c * const shared_dh_key,

	const u8_t * const prime,

	const u32_t prime_length,

	const u8_t * const group_generator,

	const u32_t group_generator_length)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);	

	eap_status_e status = eap_status_ok;

	TRAPD(err, generate_g_power_to_xyL(

		own_private_dh_key,

		peer_public_dh_key,

		shared_dh_key,

		prime,

		prime_length,

		group_generator,

		group_generator_length));

	if (err != KErrNone)

	{

		status = ((m_am_tools)->convert_am_error_to_eapol_error(err));

	} 

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	return EAP_STATUS_RETURN(m_am_tools, status);

}

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

void eap_am_crypto_symbian_c::generate_g_power_to_xyL(

	const eap_variable_data_c * const own_private_dh_key,

	const eap_variable_data_c * const peer_public_dh_key,

	eap_variable_data_c * const shared_dh_key,

	const u8_t * const prime,

	const u32_t prime_length,

	const u8_t * const group_generator,

	const u32_t group_generator_length)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	eap_status_e status(eap_status_ok);

	EAP_TRACE_DATA_DEBUG(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO, (EAPL("peer_public_dh_key"),

		peer_public_dh_key->get_data(peer_public_dh_key->get_data_length()),

		peer_public_dh_key->get_data_length()));

	// PUBLIC KEY

	TPtrC8 peer_key(

		peer_public_dh_key->get_data(peer_public_dh_key->get_data_length()), 

		peer_public_dh_key->get_data_length());

	if (peer_key.Ptr() == 0)

	{

		User::Leave(KErrArgument);

	}

	RInteger Y = RInteger::NewL(peer_key);

	CleanupStack::PushL(Y); 

	TPtrC8 peer_prime(

		prime, 

		prime_length);

	if (peer_prime.Ptr() == 0)

	{

		User::Leave(KErrArgument);

	}

	RInteger N = RInteger::NewL(peer_prime);

	CleanupStack::PushL(N); 

	TPtrC8 peer_generator(

		group_generator, 

		group_generator_length);

	if (peer_prime.Ptr() == 0)

	{

		User::Leave(KErrArgument);

	}

	RInteger G = RInteger::NewL(peer_generator);

	CleanupStack::PushL(G); 

	CDHPublicKey* publicKey = CDHPublicKey::NewL(N, G, Y);

	CleanupStack::Pop(&G); // The parameters are freed by CDHPublicKey

	CleanupStack::Pop(&N); // The parameters are freed by CDHPublicKey

	CleanupStack::Pop(&Y); // The parameters are freed by CDHPublicKey

	CleanupStack::PushL(publicKey);

	// PRIVATE KEY

	RInteger Npriv = RInteger::NewL(peer_prime);

	CleanupStack::PushL(Npriv);

	RInteger Gpriv = RInteger::NewL(peer_generator); // !

	CleanupStack::PushL(Gpriv);

	TPtrC8 private_key(

		own_private_dh_key->get_data(own_private_dh_key->get_data_length()), 

		own_private_dh_key->get_data_length());

	if (private_key.Ptr() == 0)

	{

		User::Leave(KErrArgument);

	}

	RInteger x = RInteger::NewL(private_key);

	CleanupStack::PushL(x); 

	CDHPrivateKey* privateKey = CDHPrivateKey::NewL(Npriv, Gpriv, x);

	CleanupStack::Pop(&x);

	CleanupStack::Pop(&Gpriv);

	CleanupStack::Pop(&Npriv);

	CleanupStack::PushL(privateKey);

	CDH* dh = CDH::NewL(*privateKey);

	CleanupStack::PushL(dh);

	// Have to do const_cast so that the object can be pushed... strange...

	HBufC8* p = const_cast<HBufC8*>(dh->AgreeL(*publicKey));

	CleanupStack::PushL(p);

	// Copy the shared key

	status = shared_dh_key->set_copy_of_buffer(const_cast<HBufC8*>(p)->Des().Ptr(), p->Length());

	if (status != eap_status_ok)

	{		

		User::Leave(KErrNoMemory);

	}

	CleanupStack::PopAndDestroy(p);  // p, dh, publicKey, privateKey

	CleanupStack::PopAndDestroy(dh);  // p, dh, publicKey, privateKey

	CleanupStack::PopAndDestroy(privateKey);  // p, dh, publicKey, privateKey

	CleanupStack::PopAndDestroy(publicKey);  // p, dh, publicKey, privateKey

	EAP_TRACE_DATA_DEBUG(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO, (EAPL("     shared_dh_key"),

		shared_dh_key->get_data(shared_dh_key->get_data_length()),

		shared_dh_key->get_data_length()));

}

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

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_symbian_c::dh_cleanup(

		const eap_variable_data_c * const /*dh_context*/)

{	

	return eap_status_ok;

}

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

EAP_FUNC_EXPORT u32_t eap_am_crypto_symbian_c::get_sha_256_digest_length(

	eap_variable_data_c * const sha_256_context)

{

	eap_am_crypto_sha_256_c * const sha_256 = reinterpret_cast<eap_am_crypto_sha_256_c *>(

		sha_256_context->get_data(sizeof(eap_am_crypto_sha_256_c * const)));

	if (sha_256 == 0

		|| sha_256->get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_key_error);

	}

	return sha_256->get_digest_length();

}

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

EAP_FUNC_EXPORT u32_t eap_am_crypto_symbian_c::get_sha_256_block_size(

	eap_variable_data_c * const sha_256_context)

{

	eap_am_crypto_sha_256_c * const sha_256 = reinterpret_cast<eap_am_crypto_sha_256_c *>(

		sha_256_context->get_data(sizeof(eap_am_crypto_sha_256_c * const)));

	if (sha_256 == 0

		|| sha_256->get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_key_error);

	}

	return sha_256->get_block_size();

}

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

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_symbian_c::sha_256_init(

	eap_variable_data_c * const sha_256_context)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	eap_am_crypto_sha_256_c * sha_256 = 0;

	if (sha_256_context->get_is_valid_data() == true)

	{

		sha_256 = reinterpret_cast<eap_am_crypto_sha_256_c *>(

			sha_256_context->get_data(sizeof(eap_am_crypto_sha_256_c * const)));

		if (sha_256 == 0

			|| sha_256->get_is_valid() == false)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

		}

	}

	eap_status_e status = eap_status_process_general_error;

	if (sha_256 == 0)

	{

		sha_256 = new eap_am_crypto_sha_256_c(m_am_tools);

		if (sha_256 == 0

			|| sha_256->get_is_valid() == false)

		{

			delete sha_256;

			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

		}

		status = sha_256_context->set_buffer(sha_256, sizeof(sha_256), false, true);

		if (status != eap_status_ok)

		{

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

	}

	status = sha_256->hash_init();

	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 eap_am_crypto_symbian_c::sha_256_update(

	eap_variable_data_c * const sha_256_context,

	const u8_t * const data,

	const u32_t data_length)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	EAP_ASSERT(sha_256_context->get_is_valid_data() == true);

	eap_am_crypto_sha_256_c * const sha_256 = reinterpret_cast<eap_am_crypto_sha_256_c *>(

		sha_256_context->get_data(sizeof(eap_am_crypto_sha_256_c * const)));

	if (sha_256 == 0

		|| sha_256->get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

	}

	eap_status_e status = sha_256->hash_update(

		data,

		data_length);

	if (status != eap_status_ok)

	{

		EAP_TRACE_DEBUG(

			m_am_tools,

			TRACE_FLAGS_DEFAULT,

			(EAPL("ERROR: eap_am_crypto_symbian_c::sha_256_update(), failed status = %d\n"),

			 status));

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

		return EAP_STATUS_RETURN(m_am_tools, status);

	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	return EAP_STATUS_RETURN(m_am_tools, status);

}

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

EAP_FUNC_EXPORT eap_status_e eap_am_crypto_symbian_c::sha_256_final(

	eap_variable_data_c * const sha_256_context,

	u8_t * const message_digest,

	u32_t *md_length_or_null)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_EAP_AM_CRYPTO);

	EAP_ASSERT(sha_256_context->get_is_valid_data() == true);

	eap_am_crypto_sha_256_c * const sha_256 = reinterpret_cast<eap_am_crypto_sha_256_c *>(

		sha_256_context->get_data(sizeof(eap_am_crypto_sha_256_c * const)));

	if (sha_256 == 0

		|| sha_256->get_is_valid() == false)

	{