/*
* Copyright (c) 2006-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 "rsashim.h"
#include <cryptospi/cryptoasymmetriccipherapi.h>
#include <cryptospi/cryptosignatureapi.h>
#include <cryptospi/cryptospidef.h>
#include "keyconverter.h"
#include <cryptospi/keys.h>

#include "../common/inlines.h"


using namespace CryptoSpi;

// CRSAPKCS1v15EncryptorShim ////////////////////////////////////////////////////////

CRSAPKCS1v15EncryptorShim* CRSAPKCS1v15EncryptorShim::NewL(const CRSAPublicKey& aKey)
	{
	CRSAPKCS1v15EncryptorShim* self = CRSAPKCS1v15EncryptorShim::NewLC(aKey);
	CleanupStack::Pop(self);
	return self;
	}

CRSAPKCS1v15EncryptorShim* CRSAPKCS1v15EncryptorShim::NewLC(const CRSAPublicKey& aKey)
	{
	CRSAPKCS1v15EncryptorShim* self = new (ELeave) CRSAPKCS1v15EncryptorShim(aKey);
	CleanupStack::PushL(self);
	self->ConstructL(aKey);
	return self;
	}

CRSAPKCS1v15EncryptorShim::CRSAPKCS1v15EncryptorShim(const CRSAPublicKey& aKey)
	: CRSAPKCS1v15Encryptor(aKey)
	{
	}

CRSAPKCS1v15EncryptorShim::~CRSAPKCS1v15EncryptorShim()
	{
	delete iAsymmetricCipherImpl;
	delete iKey;
	}

void CRSAPKCS1v15EncryptorShim::ConstructL(const CRSAPublicKey& aKey)
	{
	iKey = KeyConverter::CreateKeyL(aKey);
	CAsymmetricCipherFactory::CreateAsymmetricCipherL(
												iAsymmetricCipherImpl,
												KRsaCipherUid,
												*iKey,
												KCryptoModeEncryptUid,
												KPaddingModePkcs1_v1_5_EncryptionUid,
												NULL);
	}

void CRSAPKCS1v15EncryptorShim::EncryptL(const TDesC8& aInput, TDes8& aOutput) const
	{
	iAsymmetricCipherImpl->ProcessL(aInput, aOutput);
	}

TInt CRSAPKCS1v15EncryptorShim::MaxInputLength(void) const
	{
	TInt maxInputLength=0; 
	TRAPD(err, maxInputLength=iAsymmetricCipherImpl->GetMaximumInputLengthL())
	if (err==KErrNone)
		{
		return maxInputLength;
		}
	else
		{
		return err;
		}
	}

TInt CRSAPKCS1v15EncryptorShim::MaxOutputLength(void) const
	{
	TInt maxOutputLength=0; 
	TRAPD(err, maxOutputLength=iAsymmetricCipherImpl->GetMaximumOutputLengthL())
	if (err==KErrNone)
		{
		return maxOutputLength;
		}
	else
		{
		return err;
		}
	}

// CRSAPKCS1v15DecryptorShim ////////////////////////////////////////////////////////
CRSAPKCS1v15DecryptorShim* CRSAPKCS1v15DecryptorShim::NewL(const CRSAPrivateKey& aKey)
	{
	CRSAPKCS1v15DecryptorShim* self = CRSAPKCS1v15DecryptorShim::NewLC(aKey);
	CleanupStack::Pop(self);
	return self;
	}


CRSAPKCS1v15DecryptorShim* CRSAPKCS1v15DecryptorShim::NewLC(const CRSAPrivateKey& aKey)
	{
	CRSAPKCS1v15DecryptorShim* self = new (ELeave) CRSAPKCS1v15DecryptorShim(aKey);
	CleanupStack::PushL(self);
	self->ConstructL(aKey);
	return self;
	}

CRSAPKCS1v15DecryptorShim::CRSAPKCS1v15DecryptorShim(const CRSAPrivateKey& aKey)
	: CRSAPKCS1v15Decryptor(aKey)
	{
	}

CRSAPKCS1v15DecryptorShim::~CRSAPKCS1v15DecryptorShim()
	{
	delete iAsymmetricCipherImpl;
	delete iKey;
	}

void CRSAPKCS1v15DecryptorShim::ConstructL(const CRSAPrivateKey& aKey)
	{
	iKey = KeyConverter::CreateKeyL(aKey);
	CAsymmetricCipherFactory::CreateAsymmetricCipherL(
												iAsymmetricCipherImpl,
												KRsaCipherUid,
												*iKey,
												KCryptoModeDecryptUid,
												KPaddingModePkcs1_v1_5_EncryptionUid,
												NULL);
	}

void CRSAPKCS1v15DecryptorShim::DecryptL(const TDesC8& aInput, TDes8& aOutput) const
	{
	iAsymmetricCipherImpl->ProcessL(aInput, aOutput);
	}

TInt CRSAPKCS1v15DecryptorShim::MaxInputLength(void) const
	{
	TInt maxInputLength=0; 
	TRAPD(err, maxInputLength=iAsymmetricCipherImpl->GetMaximumInputLengthL())
	if (err==KErrNone)
		{
		return maxInputLength;
		}
	else
		{
		return err;
		}
	}

TInt CRSAPKCS1v15DecryptorShim::MaxOutputLength(void) const
	{
	TInt maxOutputLength=0; 
	TRAPD(err, maxOutputLength=iAsymmetricCipherImpl->GetMaximumOutputLengthL())
	if (err==KErrNone)
		{
		return maxOutputLength;
		}
	else
		{
		return err;
		}
	}

// CRSAPKCS1v15SignerShim ////////////////////////////////////////////////////////
CRSAPKCS1v15SignerShim* CRSAPKCS1v15SignerShim::NewL(const CRSAPrivateKey& aKey)
	{
	CRSAPKCS1v15SignerShim* self = CRSAPKCS1v15SignerShim::NewLC(aKey);
	CleanupStack::Pop(self);
	return self;
	}

CRSAPKCS1v15SignerShim* CRSAPKCS1v15SignerShim::NewLC(const CRSAPrivateKey& aKey)
	{
	CRSAPKCS1v15SignerShim* self = new (ELeave) CRSAPKCS1v15SignerShim(aKey);
	CleanupStack::PushL(self);
	self->ConstructL(aKey);
	return self;
	}

CRSASignature* CRSAPKCS1v15SignerShim::SignL(const TDesC8& aInput) const
	{
	//Sign the input data
	CCryptoParams* signature = CCryptoParams::NewLC();
	iSignerImpl->SignL(aInput, *signature);

	//Retrieve the S in RSA signature from the array
	const TInteger& cS=signature->GetBigIntL(KRsaSignatureParameterSUid);

	//Make copies of the RSA signature
	RInteger s=RInteger::NewL(cS);
	CleanupClosePushL(s);	

	//Create the RSA signature object, the ownership of s is transfered to rsaSig
	CRSASignature* rsaSig=CRSASignature::NewL(s);

	//Cleanup
	CleanupStack::Pop(&s);
	CleanupStack::PopAndDestroy(signature);
	return rsaSig;
	}

TInt CRSAPKCS1v15SignerShim::MaxInputLength(void) const
	{
	TInt maxInputLength=0; 
	TRAPD(err, maxInputLength=iSignerImpl->GetMaximumInputLengthL())
	if (err==KErrNone)
		{
		return maxInputLength;
		}
	else
		{
		return err;
		}
	}
	
TInt CRSAPKCS1v15SignerShim::MaxOutputLength(void) const
	{
	TInt maxOutputLength=0; 
	TRAPD(err, maxOutputLength=iSignerImpl->GetMaximumOutputLengthL())
	if (err==KErrNone)
		{
		return maxOutputLength;
		}
	else
		{
		return err;
		}
	}

CRSAPKCS1v15SignerShim::~CRSAPKCS1v15SignerShim(void)
	{
	delete iSignerImpl;
	delete iKey;
	}

CRSAPKCS1v15SignerShim::CRSAPKCS1v15SignerShim(const CRSAPrivateKey& aKey)
	: CRSAPKCS1v15Signer(aKey)
	{
	}
	
void CRSAPKCS1v15SignerShim::ConstructL(const CRSAPrivateKey& aKey)
	{
	iKey = KeyConverter::CreateKeyL(aKey);
	CSignatureFactory::CreateSignerL(
									iSignerImpl,
									KRsaSignerUid,
									*iKey,
									KPaddingModePkcs1_v1_5_SignatureUid,
									NULL);
	}

// CRSAPKCS1v15VerifierShim ////////////////////////////////////////////////////////
CRSAPKCS1v15VerifierShim* CRSAPKCS1v15VerifierShim::NewL(const CRSAPublicKey& aKey)
	{
	CRSAPKCS1v15VerifierShim* self = CRSAPKCS1v15VerifierShim::NewLC(aKey);
	CleanupStack::Pop(self);
	return self;
	}

CRSAPKCS1v15VerifierShim* CRSAPKCS1v15VerifierShim::NewLC(const CRSAPublicKey& aKey)
	{
	CRSAPKCS1v15VerifierShim* self = new (ELeave) CRSAPKCS1v15VerifierShim(aKey);
	CleanupStack::PushL(self);
	self->ConstructL(aKey);
	return self;
	}
	
TBool CRSAPKCS1v15VerifierShim::VerifyL(const TDesC8& aInput, const CRSASignature& aSignature) const
	{
	//create the array format rsa signature for the new crypto spi
	CCryptoParams* rsaSig = CCryptoParams::NewLC();

	rsaSig->AddL(aSignature.S(), KRsaSignatureParameterSUid);

	//pass the signature and input to crypto spi to be verified
	TBool verificationResult = EFalse;	
	iVerifierImpl->VerifyL(aInput, *rsaSig, verificationResult);

	//Cleanup the array
	CleanupStack::PopAndDestroy(rsaSig);
	return verificationResult;
	}

HBufC8* CRSAPKCS1v15VerifierShim::InverseSignLC(const CRSASignature& aSignature) const
	{
	//create the array format rsa signature for the new crypto spi
	CCryptoParams* rsaSig = CCryptoParams::NewLC();

	rsaSig->AddL(aSignature.S(), KRsaSignatureParameterSUid);

	//pass the signature and input to crypto spi to be verified
	HBufC8* output = NULL;
	iVerifierImpl->InverseSignL(output, *rsaSig);

	//Cleanup the array
	CleanupStack::PopAndDestroy(rsaSig);

	// leave output on the cleanup stack
	CleanupStack::PushL(output);
	return output;
	}

TInt CRSAPKCS1v15VerifierShim::MaxInputLength(void) const
	{
	TInt maxInputLength=0; 
	TRAPD(err, maxInputLength=iVerifierImpl->GetMaximumInputLengthL())
	if (err==KErrNone)
		{
		return maxInputLength;
		}
	else
		{
		return err;
		}
	}
	
TInt CRSAPKCS1v15VerifierShim::MaxOutputLength(void) const
	{
	TInt maxOutputLength=0; 
	TRAPD(err, maxOutputLength=iVerifierImpl->GetMaximumOutputLengthL())
	if (err==KErrNone)
		{
		return maxOutputLength;
		}
	else
		{
		return err;
		}
	}

CRSAPKCS1v15VerifierShim::~CRSAPKCS1v15VerifierShim(void)
	{
	delete iVerifierImpl;
	delete iKey;
	}

CRSAPKCS1v15VerifierShim::CRSAPKCS1v15VerifierShim(const CRSAPublicKey& aKey)
	: CRSAPKCS1v15Verifier(aKey)
	{
	}

void CRSAPKCS1v15VerifierShim::ConstructL(const CRSAPublicKey& aKey)
	{
	iKey = KeyConverter::CreateKeyL(aKey);
	CSignatureFactory::CreateVerifierL(
									iVerifierImpl,
									KRsaVerifierUid,
									*iKey,
									KPaddingModePkcs1_v1_5_SignatureUid,
									NULL);
	}