/*
* Copyright (c) 2003-2010 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: 
*
*/


#include <bigint.h>
#include <cryptospi/keys.h>
#include <asymmetrickeys.h>
#include <cryptospi/cryptospidef.h>
#include <cryptospi/cryptoparams.h>
#include "rsafunction.h"
#include "../../../source/bigint/mont.h"

using namespace CryptoSpi;

// Public Encrypt
void RSAFunction::EncryptL(const CKey& aPublicKey,
	const TInteger& aInput, RInteger& aOutput)
	{
	const TInteger& N = aPublicKey.GetBigIntL(KRsaKeyParameterNUid);
	const TInteger& E = aPublicKey.GetBigIntL(KRsaKeyParameterEUid);
	FunctionL(N, E, aInput, aOutput);
	}

// Private Decrypt
void RSAFunction::DecryptL(const CKey& aPrivateKey, const TInteger& aInput, RInteger& aOutput)
	{
	if (aPrivateKey.KeyProperty().iKeyType == KRsaPrivateKeyStandardUid)
		{
		const TInteger& N = aPrivateKey.GetBigIntL(KRsaKeyParameterNUid);
		const TInteger& D = aPrivateKey.GetBigIntL(KRsaKeyParameterDUid);
		FunctionL(N, D, aInput, aOutput);
		}
	else if (aPrivateKey.KeyProperty().iKeyType == KRsaPrivateKeyCRTUid)
		{
		FunctionCRTL(aPrivateKey, aInput, aOutput);
		}
	else
		{
		User::Leave(KErrNotSupported);
		}
	}

// Private Encrypt
void RSAFunction::SignL(const CKey& aPrivateKey, const TInteger& aInput, RInteger& aOutput)
	{
	if (aPrivateKey.KeyProperty().iKeyType == KRsaPrivateKeyStandardUid)
		{
		const TInteger& N = aPrivateKey.GetBigIntL(KRsaKeyParameterNUid);
		const TInteger& D = aPrivateKey.GetBigIntL(KRsaKeyParameterDUid);
		FunctionL(N, D, aInput, aOutput);
		}
	else if (aPrivateKey.KeyProperty().iKeyType == KRsaPrivateKeyCRTUid)
		{
		FunctionCRTL(aPrivateKey, aInput, aOutput);
		}
	else
	{
		User::Leave(KErrNotSupported);
	}
}

// Public Decrypt
void RSAFunction::VerifyL(const CKey& aPublicKey,
	const TInteger& aInput, RInteger& aOutput)
	{
	const TInteger& N = aPublicKey.GetBigIntL(KRsaKeyParameterNUid);
	const TInteger& E = aPublicKey.GetBigIntL(KRsaKeyParameterEUid);
	FunctionL(N, E, aInput, aOutput);
	}
	
// The RSA Trapdoor Function
void RSAFunction::FunctionL(const TInteger& aModulus, const TInteger& aExponent, 
							 const TInteger& aBase, RInteger& aOutput)
	{
	IsInputValidL(aBase, aModulus);

	aOutput = TInteger::ModularExponentiateL(aBase, aExponent, aModulus);
	}

// The CRT version of the RSA Trapdoor Function
void RSAFunction::FunctionCRTL(const CKey& aPrivateKey,
								const TInteger& aInput, RInteger& aOutput)
	{
	const TInteger& N = aPrivateKey.GetBigIntL(KRsaKeyParameterNUid);
	IsInputValidL(aInput, N);

	const TInteger& P = aPrivateKey.GetBigIntL(KRsaKeyParameterPUid);
	const TInteger& Q = aPrivateKey.GetBigIntL(KRsaKeyParameterQUid);
	const TInteger& DP = aPrivateKey.GetBigIntL(KRsaKeyParameterDPUid);
	const TInteger& DQ = aPrivateKey.GetBigIntL(KRsaKeyParameterDQUid);
	const TInteger& QInv = aPrivateKey.GetBigIntL(KRsaKeyParameterQInvUid);

	CMontgomeryStructure* montP = CMontgomeryStructure::NewLC(P);
	CMontgomeryStructure* montQ = CMontgomeryStructure::NewLC(Q);
	
	// m1 = c^(dP) mod(p)
	RInteger inputReduced = aInput.ModuloL(P);
	CleanupStack::PushL(inputReduced);
	const TInteger& m1 = montP->ExponentiateL(inputReduced, DP);
	CleanupStack::PopAndDestroy(&inputReduced);

	// m2 = c^(dQ) mod(Q)
	inputReduced = aInput.ModuloL(Q);
	CleanupStack::PushL(inputReduced);
	const TInteger& m2 = montQ->ExponentiateL(inputReduced, DQ);
	CleanupStack::PopAndDestroy(&inputReduced);
	
	// Calculate CRT
	// h = (m1-m2) qInv mod(p)
	RInteger h = m1.MinusL(m2);
	CleanupStack::PushL(h);
	h *= QInv;
	h %= P;

	// m = m2 + q * h
	h *= Q;
	h += m2;

	aOutput = h;
	CleanupStack::Pop(&h);

	CleanupStack::PopAndDestroy(montQ);
	CleanupStack::PopAndDestroy(montP);
	}