/*

 * Copyright (c) 1998-2009 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 "tdsavector.h"

 #include "tvectorutils.h"

 #include "t_input.h"

 #include <bigint.h>

 #include "tbrokenrandom.h"

 const TInt KSha1HashLength = 20; 

 ////////////////////////////////////////////////////////////////////////////////

 // CDSASignVector

 ////////////////////////////////////////////////////////////////////////////////

 CTestAction* CDSASignVector::NewL(RFs& aFs,

                                   CConsoleBase& aConsole,

                                   Output& aOut, 

                                   const TTestActionSpec& aTestActionSpec)

 	{

 	CTestAction* self = CDSASignVector::NewLC(aFs, aConsole, aOut, aTestActionSpec);

 	CleanupStack::Pop();

 	return self;

 	}

 CTestAction* CDSASignVector::NewLC(RFs& aFs,

                                    CConsoleBase& aConsole,

                                    Output& aOut, 

                                    const TTestActionSpec& aTestActionSpec)

 	{

 	CDSASignVector* self = new(ELeave) CDSASignVector(aFs, aConsole, aOut);

 	CleanupStack::PushL(self);

 	self->ConstructL(aTestActionSpec);

 	return self;

 	}

 CDSASignVector::~CDSASignVector()

 	{

     delete iPrivKey;

 	delete iSignature;

 	delete iK;

 	delete iSigInput;

 	}

 CDSASignVector::CDSASignVector(RFs& /*aFs*/, 

                                CConsoleBase& aConsole,

                                Output& aOut)					 

     : CVectorTest(aConsole, aOut)

 	{

 	}

 void CDSASignVector::ConstructL(const TTestActionSpec& aTestActionSpec)

 	{

 	CVectorTest::ConstructL(aTestActionSpec);

     iPrivKey = VectorUtils::ReadDSAPrivateKeyL(aTestActionSpec.iActionBody);

 	iMessage.Set(Input::ParseElement(aTestActionSpec.iActionBody, _L8("<m>")));

 	iK = Input::ParseElementHexL(aTestActionSpec.iActionBody, _L8("<k>"));

 	iSignature = VectorUtils::ReadDSASignatureL(aTestActionSpec.iActionBody);

 	iSigInput = CHashingSignatureInput::NewL(CMessageDigest::ESHA1);

 	iSigInput->Update(iMessage);

 	}

 void CDSASignVector::DoPerformActionL()

 	{

 	__UHEAP_MARK;

 	CRandomSetSource* random = new(ELeave)CRandomSetSource(*iK);

 	SetThreadRandomLC(random);

     CDSASigner* signer = CDSASigner::NewLC(*iPrivKey);

 	const CDSASignature* testSig = signer->SignL(iSigInput->Final());

     iResult = (*testSig == *iSignature);

 	delete testSig;

     CleanupStack::PopAndDestroy(signer);

     CDSASigner* signer1 = CDSASigner::NewL(*iPrivKey);

     CleanupStack::PushL(signer1);

     if (signer1->MaxInputLength() != KSha1HashLength)

     	{

         iResult = EFalse;

         }

     CleanupStack::PopAndDestroy(signer1); 

 	CleanupStack::PopAndDestroy(); //SetThreadRandomLC

 	__UHEAP_MARKEND;

 	}

 void CDSASignVector::DoPerformanceTestActionL()

 	{

 	iResult = ETrue;

 	}

 void CDSASignVector::DoCheckResult(TInt /*aError*/)

 	{

 //	If using Keith's fixed up testframework for testing failures, iResult will 

 //	have already been corrected for a deliberate fail result.

 //	If not using Keith's testframework iResult is still a fail result at this

 //	point, so now's the time to adjust for deliberate failure.

 	if (!iResult)

 		iResult = (iResult && iExpectedResult) || (!iResult && !iExpectedResult);

 	if( iResult == EFalse )

 		{

 		iConsole.Printf(_L("X"));

 		}

 	else 

 		{

 		iConsole.Printf(_L("."));

 		}

 	}

 ////////////////////////////////////////////////////////////////////////////////

 // CDSAVerifyVector

 ////////////////////////////////////////////////////////////////////////////////

 CTestAction* CDSAVerifyVector::NewL(RFs& aFs,

                                   CConsoleBase& aConsole,

                                   Output& aOut, 

                                   const TTestActionSpec& aTestActionSpec)

 	{

 	CTestAction* self = CDSAVerifyVector::NewLC(aFs, aConsole, aOut, aTestActionSpec);

 	CleanupStack::Pop();

 	return self;

 	}

 CTestAction* CDSAVerifyVector::NewLC(RFs& aFs,

                                    CConsoleBase& aConsole,

                                    Output& aOut, 

                                    const TTestActionSpec& aTestActionSpec)

 	{

 	CDSAVerifyVector* self = new(ELeave) CDSAVerifyVector(aFs, aConsole, aOut);

 	CleanupStack::PushL(self);

 	self->ConstructL(aTestActionSpec);

 	return self;

 	}

 CDSAVerifyVector::~CDSAVerifyVector()

 	{

     delete iPubKey;

 	delete iSignature;

 	delete iMessage;

 	delete iSigInput;

 	}

 CDSAVerifyVector::CDSAVerifyVector(RFs& /*aFs*/, 

                                    CConsoleBase& aConsole,

                                    Output& aOut)					 

     : CVectorTest(aConsole, aOut)

 	{

 	}

 void CDSAVerifyVector::ConstructL(const TTestActionSpec& aTestActionSpec)

 	{

 	CVectorTest::ConstructL(aTestActionSpec);

     iPubKey = VectorUtils::ReadDSAPublicKeyL(aTestActionSpec.iActionBody);

 	TPtrC8 message(Input::ParseElement(aTestActionSpec.iActionBody, _L8("<m>")));

 	if (message.Length()==0)	

 		iMessage = Input::ParseElementHexL(aTestActionSpec.iActionBody, _L8("<hexm>"));

 	else

 		iMessage = message.AllocL();

 	iSignature = VectorUtils::ReadDSASignatureL(aTestActionSpec.iActionBody);

 	iSigInput = CHashingSignatureInput::NewL(CMessageDigest::ESHA1);

 	iSigInput->Update(*iMessage);

 	}	

 void CDSAVerifyVector::DoPerformActionL()

 	{

 	__UHEAP_MARK;

     CDSAVerifier* verifier = CDSAVerifier::NewLC(*iPubKey);

     iResult = verifier->VerifyL(iSigInput->Final(), *iSignature);

     CleanupStack::PopAndDestroy(verifier);

 	__UHEAP_MARKEND;

 	}

 void CDSAVerifyVector::DoPerformanceTestActionL()

 	{

 	iResult = ETrue;

 	}

 void CDSAVerifyVector::DoCheckResult(TInt /*aError*/)

 	{

 //	If using Keith's fixed up testframework for testing failures, iResult will 

 //	have already been corrected for a deliberate fail result.

 //	If not using Keith's testframework iResult is still a fail result at this

 //	point, so now's the time to adjust for deliberate failure.

 	if (!iResult)

 		iResult = (iResult && iExpectedResult) || (!iResult && !iExpectedResult);

 	if( iResult == EFalse )

 		{

 		iConsole.Printf(_L("X"));

 		}

 	else 

 		{

 		iConsole.Printf(_L("."));

 		}

 	}