--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoservices/certificateandkeymgmt/tpkcs12intgrtn/src/tpkcs12libteststep.cpp Wed Jul 08 11:25:26 2009 +0100
@@ -0,0 +1,1429 @@
+/*
+* Copyright (c) 2005-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:
+* This file is used for the verification function of the pkcs12 file
+*
+*/
+
+
+
+
+/**
+ @file
+ @internalTechnology
+*/
+
+// System Include
+#include <testexecutelog.h>
+
+//User Include
+#include "tpkcs12libteststep.h"
+#include "tpkcs12data.h"
+#include "tpkcs12common.h"
+
+using namespace PKCS12;
+
+const TInt KBagDataLength = 7;
+const TInt KContentInfoLength = 11;
+/**
+Description:constructor:used for initialization of the variables declared
+@test
+@internalTechnology
+*/
+CPKCS12LibTestStep::CPKCS12LibTestStep()
+ {
+ iActualResult=ETrue;
+ iUnitTest=EFalse;
+ iUnitTestContinueFlag = ETrue;
+ iExpectedError = ETrue;
+ iExpectedResult=KPositiveTest;
+ }
+/**
+Description:Destructor
+@test
+@internalTechnology
+*/
+CPKCS12LibTestStep::~CPKCS12LibTestStep()
+ {
+ iFileSession.Close();
+ delete iParser;
+ iPrivacyPassword.ResetAndDestroy();
+ }
+
+/**
+Function is intended to parse the pkcs12 file, compare the results and
+log the same
+@internalTechnology:
+@return:TVerdict -returns EFail if there is a failure else EPass
+@test
+@leave:- if memory allocation fails
+*/
+TVerdict CPKCS12LibTestStep::doTestStepL()
+ {
+ //__UHEAP_MARK;
+ TPtrC integrityMode(KNullDesC);
+ TPtrC integrityPassword(KNullDesC);
+ TPtrC privacyPassword(KNullDesC);
+ TPtrC dataPath(KNullDesC);
+ TBool flagReturn=ETrue;
+
+
+ if(iFileSession.Connect())
+ {
+ INFO_PRINTF1(_L("File server session failed"));
+ flagReturn=EFalse;
+ }
+
+ if(flagReturn)
+ {
+ if((!GetStringFromConfig(KMainSec,KFilePath,dataPath)) ||
+ !GetStringFromConfig(KMainSec,KIntegrityMode,integrityMode))
+ {
+ SetTestStepResult(EAbort);
+ ERR_PRINTF1(_L("Input Data not found in ini file"));
+ flagReturn=EFalse;
+ }
+ }
+ //Check the input
+ if(flagReturn)
+ {
+ if(!GetBoolFromConfig(KMainSec,KUnitTest,iUnitTest))
+ {
+ iUnitTest=EFalse;
+ }
+ //Password Integrity Mode
+ if(integrityMode.CompareF(KPassword)==0)
+ {
+ if(!GetStringFromConfig(KMainSec,KIntegrityPassword,integrityPassword))
+ {
+ ERR_PRINTF1(_L("Problem in the Main section of the ini file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ else
+ {
+
+ iParser = CPkcs12Parser::NewL();
+ // set the integrity password
+ iParser->SetIntegrityPasswordL(integrityPassword);
+ // set the datapath
+ iParser->SetDataL(dataPath);
+ //set the privacy password
+ ParsePrivacyPwdL();
+ //parse the pkcs12 file
+ iParser->ParseL();
+
+ if(!GetBoolFromConfig(KMainSec,KIntegrityValid,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("Integrity valid not found in ini file"));
+ iExpectedResult=KPositiveTest;
+ }
+ if(!VerifyMainSecL())
+ {
+ ERR_PRINTF1(_L("Main section failed"));
+ flagReturn=EFalse;
+ }
+ else if(!iUnitTestContinueFlag)
+ {
+ SetTestStepResult(EPass);
+ delete iParser;
+ iParser = NULL;
+ flagReturn = EFalse;
+ }
+ }
+ }
+ else if(integrityMode.CompareF(KPublicIntegrity)==0)
+ {
+ //public Integrity Mode
+ }
+ else
+ {
+ ERR_PRINTF1(_L("Integrity pwd not known in ini file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ }
+ if(flagReturn)
+ {
+ //Check the Authenticated safe section
+ if(!VerifyAuthSafe())
+ {
+ ERR_PRINTF1(_L("Authenticated safe section failed"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ else if(!iUnitTestContinueFlag )
+ {
+ SetTestStepResult(EPass);
+ delete iParser;
+ iParser = NULL;
+ flagReturn = EFalse;
+ }
+ }
+ if(flagReturn)
+ {
+ //calculate the totalsafebags in the pkcs12 file
+ TInt totalsafebags = iParser->PfxHeader().TotalSafeBagCount();
+
+ //calculate the totalbags(including the safecontentsbag) in the pkcs12 file
+ TInt totalbags = totalsafebags + iParser->PfxHeader().SafecontentBagCount();
+
+ //Check the BagData section
+ if(!ChkBagDataL(totalsafebags,totalbags))
+ {
+ ERR_PRINTF1(_L("Bag Data section failed"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ else if(!iUnitTestContinueFlag)
+ {
+ delete iParser;
+ iParser = NULL;
+ flagReturn = EFalse;
+ }
+ }
+ if(flagReturn)
+ {
+ SetTestStepResult(EPass);
+ }
+
+ //__UHEAP_MARKEND;
+ return TestStepResult();
+ }
+/**
+Function is intended to verify the expected error in each section of the ini file
+@internalTechnology:
+@return:TBool:returns EFalse if there is a failure else ETrue
+@test:
+*/
+TBool CPKCS12LibTestStep::VerifyExpectedError(const TDesC& aSecName)
+ {
+ TBool flagReturn = ETrue;
+ if ( iUnitTest )
+ {
+ if(GetIntFromConfig(aSecName,KExpectedError,iExpectedError)==EFalse)
+ {
+ INFO_PRINTF1(_L("ExpectedError not found in INI File"));
+ }
+ // Checks the error returned by the library with the expected error read
+ // from the INI file.
+ TInt actualError = 0;
+
+ if ( (!aSecName.Compare(KMainSec) || !aSecName.Compare(KAuthSafeSec) ||
+ !aSecName.Compare(_L("MacData")) || (!aSecName.Left(KBagDataLength).Compare(KBagDataSec)) ||
+ (!aSecName.Left(KContentInfoLength).CompareF(KContentInfoKey))) && !iExpectedResult )
+ {
+ actualError = iParser->PfxHeader().Pkcs12ActualError();
+ }
+ if (actualError == iExpectedError)
+ {
+ INFO_PRINTF1(_L("ExpectedError matchs"));
+ iUnitTestContinueFlag = EFalse;
+ iExpectedResult = ETrue;
+ }
+ }
+
+ if(iExpectedResult!=iActualResult)
+ {
+ SetTestStepResult(EFail);
+ flagReturn= EFalse;
+ }
+ iActualResult = ETrue;
+ return flagReturn;
+ }
+/**
+Function is intended to set the privacy passwords of the contentinfotype
+@internalTechnology:
+@test:
+@leave: if leave occurs if memory allocation fails
+*/
+void CPKCS12LibTestStep::ParsePrivacyPwdL()
+ {
+ TPtrC pass(KNullDesC);
+ //to append the number to get the actual key value
+ TInt count=0;
+ //return value
+ TBool privacyPwdPresent=EFalse;
+
+ //Put all the content info privacy passwords in an array
+ do
+ {
+ TBuf<KPrivacyPwdStrLen> privacyPwdBuf(KPrivacyPassword);
+ pass.Set(KNullDesC);
+ count++;
+ //appending the count to the Keyvalue
+ privacyPwdBuf.AppendNum(count);
+ privacyPwdPresent=GetStringFromConfig(KMainSec,privacyPwdBuf,pass);
+ if(privacyPwdPresent)
+ {
+ HBufC *temp=pass.AllocLC();
+ iPrivacyPassword.AppendL(temp);
+ CleanupStack::Pop(temp);
+ }
+ }while(privacyPwdPresent);
+ iParser->SetPrivacyPassword(iPrivacyPassword);
+ }
+/**
+Function is intended to parse the main section of the ini file
+@internalTechnology:
+@return:returns EFalse if there is a failure else ETrue
+@test:
+*/
+TBool CPKCS12LibTestStep::VerifyMainSecL()
+ {
+ TBool mac=EFalse;
+ TBool flagReturn=ETrue;
+
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(KMainSec,KExpectedResult,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+ if(!GetBoolFromConfig(KMainSec,KMacPresent,mac))
+ {
+ WARN_PRINTF1(_L("Mac present not found in ini file"));
+ //default only integration test
+ mac=EFalse;
+ }
+ else if(mac && iUnitTest)
+ {
+ //call the mac data function and check for all the macdata section values
+ iActualResult=ChkMacValueL();
+ if (!iUnitTestContinueFlag)
+ {
+ return flagReturn;
+ }
+ }
+ if(!VerifyExpectedError(KMainSec))
+ {
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+ return flagReturn;
+ }
+/**
+Function is intended to parse the AuthSafe section of the ini file
+@internalTechnology:
+@return:returns EFalse if there is a failure else ETrue
+@test:
+*/
+TBool CPKCS12LibTestStep::VerifyAuthSafe()
+ {
+ TInt contentInfoCount=0;
+ TPtrC contentSection(KNullDesC);
+ TInt contentIndex=0;
+ TBool flagReturn=ETrue;
+
+ if(!GetIntFromConfig(KAuthSafeSec,KContentInfoNum,contentInfoCount))
+ {
+ ERR_PRINTF1(_L("Count not available in the inifile"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(GetIntFromConfig(KAuthSafeSec,KExpectedResult,iExpectedResult)==EFalse)
+ {
+ INFO_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ }
+ //verify positive or negative test
+ if(!VerifyExpectedError(KAuthSafeSec()))
+ {
+ INFO_PRINTF1(_L("Content Info Failure"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+ else if(!iUnitTestContinueFlag)
+ {
+ return flagReturn;
+ }
+ for(TInt i=1;i<=contentInfoCount;i++)
+ {
+ TBuf<KContentInfoBufLen> contentBuf(KContentInfoKey);
+ //Append the counter to the keyname
+ contentBuf.AppendNum(i);
+ if(!GetStringFromConfig(KAuthSafeSec,contentBuf,contentSection))
+ {
+ ERR_PRINTF1(_L("ContentSection not available in the inifile"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ break;
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(GetIntFromConfig(contentSection,KExpectedResult,iExpectedResult)==EFalse)
+ {
+ INFO_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+ // Verify before calling array to access the data.
+ if(!VerifyExpectedError(contentSection))
+ {
+ INFO_PRINTF1(_L("Content Info Failure"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ break;
+ }
+ else if(!iUnitTestContinueFlag)
+ {
+ flagReturn = ETrue;
+ break;
+ }
+ //Call the function for checking the contentinfo,pass the contntsction as parameter
+ iBagData=iParser->ArraySafeBagData()[contentIndex];
+ contentIndex++;
+ //Check the contentinfo type
+ iActualResult=ChkCIType(contentSection,*iBagData);
+ }
+ return flagReturn;
+ }
+/**
+Function is intended to parse the BagData section of the ini file
+@param-aTotalsafebags:total number of safebags
+@param-aTotalbags:total number of bags including the safecontentbags
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+@leave: if leave occurs at the ChkBagValL function
+*/
+TBool CPKCS12LibTestStep::ChkBagDataL(TInt aTotalsafebags,TInt aTotalbags)
+ {
+ TInt bagType=0;
+ TInt safeContentIndex=0;
+ TInt safeBagIndex=0;
+ CSafeContentBag* safeContentBag;
+ TBool flagReturn=ETrue;
+
+ TInt totalSafeContentsBag = iParser->PfxHeader().SafecontentBagCount();
+
+
+ //loop for the totalbags
+ for(TInt bags=0;bags<aTotalbags;bags++)
+ {
+ TBuf<KBagDataSecBufLen> bagSection(KBagDataSec);
+ //Append the bags to the sectionname :BagData1
+ bagSection.AppendNum(bags+1);
+ if(!GetIntFromConfig(bagSection,KBagType,bagType))
+ {
+ ERR_PRINTF1(_L("Not able to get the BagType from the ini file"));
+ flagReturn=EFalse;
+ break;
+ }
+ if(bagType == CDecPkcs12SafeBag::ESafeContentsBag && flagReturn)
+ {
+ //loop for the safecontents bags
+ while(safeContentIndex < totalSafeContentsBag && flagReturn)
+ {
+ safeContentBag=iParser->ArraySafeContentBag()[safeContentIndex];
+ if(!ChkSafeContsBagData(bagSection,*safeContentBag))
+ {
+ ERR_PRINTF1(_L("SafeContent Bag Failed"));
+ flagReturn=EFalse;
+ }
+ safeContentIndex++;
+ break;
+ }
+ }
+ else
+ {
+ while(safeBagIndex < aTotalsafebags && flagReturn)
+ {
+ //retrieve the safebag sructure pointer
+ iBagData=iParser->ArraySafeBagData()[safeBagIndex];
+ //Chk the BagType
+ if(!ChkBagType(bagSection,*iBagData,bagType))
+ {
+ ERR_PRINTF1(_L("Bag Type does not match"));
+ flagReturn=EFalse;
+ break;
+ }
+ if(!iUnitTestContinueFlag)
+ {
+ break;
+ }
+ iBagAttrNumVal=0;
+ if(!ChkBagAttbutesL(bagSection,*iBagData))
+ {
+ ERR_PRINTF1(_L("Failure in Attributes"));
+ flagReturn=EFalse;
+ break;
+ }
+ switch(bagType)
+ {
+ case CDecPkcs12SafeBag::ECertBag:
+ {
+ //check the bagvalue
+ if(!ChkBagValL(bagSection,*iBagData))
+ {
+ flagReturn=EFalse;
+ ERR_PRINTF1(_L("Certificate Bag Value comparison Failed"));
+ }
+ //check the certificate type
+ if(flagReturn)
+ {
+ if(!ChkCertId(bagSection,*iBagData))
+ {
+ flagReturn=EFalse;
+ ERR_PRINTF1(_L("Certificate Bag certID comparison Failed"));
+ }
+ }
+ break;
+ }
+ case CDecPkcs12SafeBag::EKeyBag:
+ {
+ if(!ChkBagValL(bagSection,*iBagData))
+ {
+ flagReturn = EFalse;
+ ERR_PRINTF1(_L("Key Bag Failed"));
+ }
+ break;
+ }
+ case CDecPkcs12SafeBag::EShroudedKeyBag:
+ {
+ if(!ChkEncodedBagValL(bagSection,*iBagData))
+ {
+ flagReturn = EFalse;
+ ERR_PRINTF1(_L("Shrouded Bag Failed"));
+ }
+ break;
+ }
+ case CDecPkcs12SafeBag::ECrlBag:
+ {
+ break;
+ }
+ case CDecPkcs12SafeBag::ESecretBag:
+ {
+ break;
+ }
+ }
+ if(flagReturn)
+ {
+ safeBagIndex++;
+ break;
+ }
+ }
+ }
+ }
+
+ return flagReturn;
+ }
+/**
+Function is intended to check the safecontents bag
+@param-aSec:BagData Section
+@param-aSfContBag:safecontent class pointer
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+*/
+TBool CPKCS12LibTestStep::ChkSafeContsBagData(TDesC& aSec,CSafeContentBag &aSfContBag)
+ {
+ TInt safeContentsCount=0;
+ TBool flagReturn=ETrue;
+ //retrieve the safecontentsbag count from ini file
+ if(!GetIntFromConfig(aSec,KSafeBagsCount,safeContentsCount))
+ {
+ ERR_PRINTF1(_L("SafeContent Bags count not found in INI file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ //compare the data with the ini file data
+ if(safeContentsCount != aSfContBag.SafeBagCount() && flagReturn)
+ {
+ ERR_PRINTF1(_L("Number of Bags in the safecontent bag is different"));
+ iActualResult=EFalse;
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(aSec,KExpectedResult,iExpectedResult))
+ {
+ INFO_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+ //check whether its a positive or a negative test
+ if(flagReturn)
+ {
+ //check whether its a positive or a negative test
+ if(!VerifyExpectedError(aSec))
+ {
+ INFO_PRINTF1(_L("SafeContentsBag Failed"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+ }
+ return flagReturn;
+ }
+/**
+Function is intended to check the content info type
+@param-aSecName:BagData Section
+@param-aBagData:safebag class pointer
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+*/
+TBool CPKCS12LibTestStep::ChkCIType(TDesC &aSecName,CSafeBagData &aBagData)
+ {
+ TInt contentType=0;
+ TBool flagReturn=ETrue;
+ //retrieve the contentype from the ini file
+ if(!GetIntFromConfig(aSecName,KContentInfoType,contentType))
+ {
+ ERR_PRINTF1(_L("ContentInfoType value not found in INI file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ //compare the contentype with the ini file data
+ if(flagReturn)
+ {
+ if(aBagData.ContentInfoType() != contentType)
+ {
+ iActualResult=EFalse;
+ INFO_PRINTF1(_L("ContentType Comparison Failed"));
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(aSecName,KExpectedResult,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+ //check whether its a positive or a negative test
+ if(!VerifyExpectedError(aSecName))
+ {
+ INFO_PRINTF1(_L("ContentInfo Failed"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+ }
+ return flagReturn;
+ }
+/**
+Function is intended to check the bag type
+@param-aSec:BagData Section
+@param-aBgDta:safebag class pointer
+@param-aId:Bag ID
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+*/
+TBool CPKCS12LibTestStep::ChkBagType(TDesC &aSec,CSafeBagData &aBagData,TInt aId)
+ {
+ TBool flagReturn=ETrue;
+
+ //check for the bagid
+ if(aId != aBagData.BagType())
+ {
+ iActualResult=EFalse;
+ INFO_PRINTF1(_L("BagType Comparision Failed"));
+ }
+
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(aSec,KExpectedResult,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+
+ //check whether its a positive or a negative test
+ if(!VerifyExpectedError(aSec))
+ {
+ INFO_PRINTF1(_L("BagType Failed"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+ return flagReturn;
+ }
+/**
+Function is intended to check the bag attributes
+@param-aSec:BagData Section
+@param-aBagData:safebag class pointer
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+*/
+TBool CPKCS12LibTestStep::ChkBagAttbutesL(TDesC &aSec,CSafeBagData &aBagData)
+ {
+ TInt numAttr=0;
+ TInt count=0;
+ TPtrC attrSec(KNullDesC);
+ TBool flagReturn=ETrue;
+
+ //retrieve the number of attributes
+ if(!GetIntFromConfig(aSec,KBagAttributesNum,numAttr))
+ {
+ WARN_PRINTF1(_L("Number of attributes not found in INI file"));
+ }
+
+ for(TInt attrindex=0;attrindex < numAttr;attrindex++)
+ {
+ TBuf<KAttributeBufLen> attrBuf(KBagAttributesKey);
+ //increment the attr counter
+ count++;
+ //appending to get the attr key from the ini file
+ attrBuf.AppendNum(count);
+
+ if(!GetStringFromConfig(aSec,attrBuf,attrSec))
+ {
+ ERR_PRINTF1(_L("Number of attributes not found in INI file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ break;
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(aSec,KExpectedResult,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+ //check whether its a positive or a negative test
+ if(!VerifyExpectedError(aSec))
+ {
+ INFO_PRINTF1(_L("BagAttributes Failed"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+ else if(!iUnitTestContinueFlag)
+ {
+ flagReturn = ETrue;
+ break;
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(aSec,KExpectedResult,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+ //check whether its a positive or a negative test
+ if(!VerifyExpectedError(aSec))
+ {
+ INFO_PRINTF1(_L("BagAttributes Failed"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+ else if(!iUnitTestContinueFlag)
+ {
+ flagReturn = ETrue;
+ break;
+ }
+ //Check the BagAttribute section
+ if(!ChkAtrSecL(attrSec,aBagData,attrindex))
+ {
+ ERR_PRINTF1(_L("Attributes comparison failed"));
+ flagReturn=EFalse;
+ break;
+ }
+ }
+ return flagReturn;
+ }
+/**
+Function is intended to check the attribute section
+@param-aSec:BagData Section
+@param-aBgDta:safebag class pointer
+@param-aIndx:attribute index
+@param-aAttrindex:attribute index
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+@leave: if leave occurs if ChkAtrValL fails
+*/
+TBool CPKCS12LibTestStep::ChkAtrSecL(TDesC &aSec,CSafeBagData &aBagData,TInt aIndex)
+ {
+ TPtrC attrId(KNullDesC);
+ TInt numVal=0;
+ CSafeBagAttribute *bagAttr;
+ TPtrC friendlyName(KFriendlyNameOid);
+ TPtrC localKey(KLocalKeyOid);
+ TBool flagReturn=ETrue;
+
+ //retrieve the attribute id
+ if(!GetStringFromConfig(aSec,KBagAttributesID,attrId))
+ {
+ ERR_PRINTF1(_L("attribute id not found in INI file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ if(flagReturn)
+ {
+ //retrieve the number of values
+ if(!GetIntFromConfig(aSec,KBagAttributeValuesNum,numVal))
+ {
+ ERR_PRINTF1(_L("total number of attribute values not found in INI file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ }
+ if(flagReturn)
+ {
+ bagAttr = aBagData.iAttributeIDs[aIndex];
+
+ //increment the Number of BagAttrValues
+ iBagAttrNumVal+=numVal;
+
+ //compare the attrval count and the attrid
+ if((bagAttr->AttributeValueCount()!=numVal) ||
+ (attrId.CompareF((bagAttr->AttributeId()))!=0))
+ {
+ iActualResult=EFalse;
+ }
+ else if((friendlyName.CompareF((bagAttr->AttributeId()))==0) ||
+ (localKey.CompareF((bagAttr->AttributeId()))==0))
+ {
+ //Check for BagAttribute values
+ if(!ChkAtrValL(aSec,aBagData,numVal))
+ {
+ iActualResult=EFalse;
+ }
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(aSec,KExpectedResult,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file"));
+ iExpectedResult=KPositiveTest;
+ }
+ //check for positive or negative test
+ if(!VerifyExpectedError(aSec))
+ {
+ INFO_PRINTF1(_L("Attributes Comparison Test Case failed"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+
+ }
+ //retrieve the bag attribute structure pointer
+ return flagReturn;
+ }
+/**
+Function is intended to check the attribute values
+@param-aSec:BagData Section
+@param-aBgDta:safebag class pointer
+@param-aNum:Bagattribute value count
+@param-aAtr:Bagattribute ID
+@param-aNumVal:Bagattribute value count
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+@leave: if memory allocation of buffer fails
+*/
+TBool CPKCS12LibTestStep::ChkAtrValL(TDesC &aSec,CSafeBagData &aBagData,TInt aNum)
+ {
+ TInt start=iBagAttrNumVal - aNum;
+ TInt end=iBagAttrNumVal + aNum;
+
+ TBool flagReturn=ETrue;
+ TInt index=0;
+ TPtrC value(KNullDesC);
+
+ HBufC8 *bufferVal;
+
+ //loop till the total number of values
+ do
+ {
+ TBuf<KBagValBufLen> bagVal(KBagAttributeValue);
+ //increment the index to append the count
+ index++;
+ //append the value
+ bagVal.AppendNum(index);
+ //retrieve the value from the ini file
+ if(!GetStringFromConfig(aSec,bagVal,value))
+ {
+ ERR_PRINTF1(_L("Bag Value not found in the ini file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ break;
+ }
+ for(TInt startIndex=start;startIndex<end;startIndex++)
+ {
+ bufferVal=aBagData.iAttributeValues[startIndex];
+
+ //check the local key value
+ if(!CompareFileDataL(value,*bufferVal))
+ {
+ ERR_PRINTF1(_L("Bag Attribute Value comparison failed"));
+ iActualResult=EFalse;
+ break;
+ }
+ else
+ {
+ iActualResult=ETrue;
+ break;
+ }
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(aSec,KExpectedResult,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+ //check for positive or negative test
+ if(!VerifyExpectedError(aSec))
+ {
+ INFO_PRINTF1(_L("Bag Value Test failed"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ break;
+ }
+ else if(!iUnitTestContinueFlag)
+ {
+ break;
+ }
+ }while(index<aNum);
+ return flagReturn;
+ }
+/**
+Function is intended to check the value.
+@param-aPValue:filepath containing the path of the file
+ retrieved from the ini file
+@param-aBufferVal:Value retrieved after parsing the pkcs12 file
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+@leave: if leave occurs if openfile fails or allocation to buffer fails
+*/
+TBool CPKCS12LibTestStep::CompareFileDataL(TDesC &aPValue,TDesC8 &aBufferVal)
+ {
+ RFile file;
+ TInt fileSize=0;
+ TBool flagReturn=ETrue;
+ // Negative Test: If mac/ macSalt is not present.
+ if (&aBufferVal)
+ {
+ //open the file
+ User::LeaveIfError(file.Open(iFileSession,aPValue,EFileRead));
+ User::LeaveIfError(file.Size(fileSize));
+ //raw data for reading the bagvalue
+ HBufC8 *rawData=HBufC8::NewMaxLC(fileSize);
+ //converting the HBufC8 to TPtr8
+ TPtr8 data(rawData->Des());
+ //read the contents of the file
+ User::LeaveIfError(file.Read(data));
+ //compare the value
+ if(rawData->CompareF(aBufferVal)!=0)
+ {
+ ERR_PRINTF1(_L("comparison failed"));
+ flagReturn=EFalse;
+ }
+ //closes the data file
+ file.Close();
+
+ CleanupStack::PopAndDestroy(rawData);
+ }
+ return flagReturn;
+ }
+/**
+Function is intended to check the algorithm id
+@param-aSecName:BagData Section
+@param-aBagData:safebagdata class pointer
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+*/
+TBool CPKCS12LibTestStep::ChkAlgId(TDesC &aSecName,CSafeBagData &aBagData)
+ {
+ TPtrC algorithm(KNullDesC);
+ TBool flagReturn=ETrue;
+ //retrieve the algorithm section name
+ if(!GetStringFromConfig(aSecName,_L("Algorithm"),algorithm))
+ {
+ ERR_PRINTF1(_L("AlgorithmID value not found in INI file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ if(flagReturn)
+ {
+ if(algorithm.CompareF((aBagData.AlgorithmId()))!=0)
+ {
+ iActualResult=EFalse;
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(aSecName,KExpectedResult,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+ //check for positive oor negative test
+ if(!VerifyExpectedError(aSecName))
+ {
+ INFO_PRINTF1(_L("Algorithm Comparison Test Case failed"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+ }
+ return flagReturn;
+ }
+/**
+Function is intended to check the certificate type
+@param-aSecName:BagData Section
+@param-aBagData:safebagdata class pointer
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+*/
+TBool CPKCS12LibTestStep::ChkCertId(TDesC &aSecName,CSafeBagData &aBagData)
+ {
+ TPtrC certid(KNullDesC);
+ TBool flagReturn=ETrue;
+ //retrieve the cert name from ini file
+ if(!GetStringFromConfig(aSecName,KCertType,certid))
+ {
+ ERR_PRINTF1(_L("certificateID value not found in INI file"));
+ SetTestStepResult(EFail);
+ flagReturn= EFalse;
+ }
+ if(flagReturn)
+ {
+ if(certid.CompareF((aBagData.CertificateId()))!=0)
+ {
+ INFO_PRINTF1(_L("certificateID comparision Failed"));
+ iActualResult=EFalse;
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(aSecName,KExpectedResult,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+ //check for positive or negative test
+ if(!VerifyExpectedError(aSecName))
+ {
+ INFO_PRINTF1(_L("Certificate Comparison Test Case failed"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+ }
+ return flagReturn;
+ }
+/**
+Function is intended to check for the bag value
+@param-aSecName:BagData Section
+@param-aBagData:safebag class pointer
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+*/
+TBool CPKCS12LibTestStep::ChkBagValL(TDesC &aSecName,CSafeBagData &aBagData)
+ {
+ TPtrC certBagPath(KNullDesC);
+ TBool flagReturn=ETrue;
+
+ //retrieve the certificate bag value
+ if(!GetStringFromConfig(aSecName,KBagValue,certBagPath))
+ {
+ ERR_PRINTF1(_L("Not able to get the CertBagValue from the ini file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ TInt fileReturn=0;
+ RFile file;
+
+ if(flagReturn)
+ {
+ fileReturn=file.Open(iFileSession,certBagPath,EFileRead);
+
+ if(fileReturn)
+ {
+ ERR_PRINTF1(_L("CertBagValue:Not able to open the file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ }
+ //raw data for reading the bagvalue
+ HBufC8 *rawData=NULL;
+ TInt filesize=0;
+ if(flagReturn)
+ {
+ User::LeaveIfError(file.Size(filesize));
+ rawData=HBufC8::NewMaxLC(filesize);
+ TPtr8 data(rawData->Des());
+ if(file.Read(data))
+ {
+ ERR_PRINTF1(_L("CertBagValue:Not able to Read the file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ }
+ if(flagReturn)
+ {
+ //compare the data
+ if(rawData->CompareF(aBagData.BagValue())!=0)
+ {
+ iActualResult=EFalse;
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(aSecName,KExpectedResult,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+ //check for positive or negative test
+ if(!VerifyExpectedError(aSecName))
+ {
+ INFO_PRINTF1(_L("BagValue Failed"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+ }
+ if(rawData!=NULL)
+ {
+ CleanupStack::PopAndDestroy(rawData);
+ }
+ if(!fileReturn)
+ {
+ file.Close();
+ }
+ return flagReturn;
+ }
+/**
+Function is intended to check for the mac value
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+@leave: if leave occurs at the CompareFileDataL function
+*/
+TBool CPKCS12LibTestStep::ChkMacValueL()
+ {
+ TPtrC mac(KNullDesC);
+ TPtrC macSalt(KNullDesC);
+ TPtrC secName(_S("MacData"));
+ TPtrC expectedError(KNullDesC);
+ TInt itCount=0;
+ TBool flagReturn=ETrue;
+
+ //retrieve the macid,macsalt and iteration count
+ if((!GetStringFromConfig(secName,KMac,mac)) ||
+ (!GetStringFromConfig(secName,KMacSalt,macSalt)) ||
+ (!GetIntFromConfig(secName,KIterationCount,itCount)))
+ {
+ ERR_PRINTF1(_L("Not able to access the mac values from ini file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ //comapre the data with the ini file
+ if((CompareFileDataL(mac,iParser->PfxHeader().MacId()) ==0)||
+ (CompareFileDataL(macSalt,iParser->PfxHeader().MacSalt()) == 0)||
+ (itCount!=iParser->PfxHeader().IterationCount()))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ flagReturn=EFalse;
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(secName,KExpectedResult,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+ if(!VerifyExpectedError(secName))
+ {
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+ return flagReturn;
+ }
+
+CTPKCS12OOMStep::CTPKCS12OOMStep()
+ {
+
+ }
+CTPKCS12OOMStep::~CTPKCS12OOMStep()
+ {
+ delete iRawData;
+ delete iAuthSafeData;
+ iFs.Close();
+ }
+/**
+Function is intended to do the OOM test.
+@internalTechnology:
+@return:TVerdict -returns EFail if there is a failure else EPass
+@leave:- if memory allocation fails
+@test
+*/
+TVerdict CTPKCS12OOMStep::doTestStepL()
+ {
+ TInt OOMTest;
+ GetIntFromConfig(ConfigSection(),_L("OOMTest"),OOMTest);
+
+ __UHEAP_MARK;
+
+ switch(OOMTest)
+ {
+ case 1:
+ {
+ CDecPkcs12* theTest = NULL;
+ theTest = CDecPkcs12::NewL(iRawData->Des());
+ delete theTest;
+ }
+ break;
+ // File Stream
+ case 2:
+ {
+ TPtrC fileName;
+ GetStringFromConfig(ConfigSection(), _L("File"), fileName);
+
+ RFile file;
+ User::LeaveIfError(file.Open(iFs, fileName, EFileRead) );
+
+ TInt size;
+ file.Size(size);
+ file.Close();
+
+ HBufC8* res = HBufC8::NewLC(size);
+ TPtr8 p(res->Des());
+ p.SetLength(size);
+
+ RFileReadStream stream;
+ User::LeaveIfError(stream.Open(iFs, fileName, EFileStream));
+ CleanupClosePushL(stream);
+
+ stream.ReadL(p, size);
+
+ CDecPkcs12* theTest = NULL;
+ theTest = CDecPkcs12::NewL(stream);
+ delete theTest;
+ CleanupStack::PopAndDestroy(2,res); // stream
+ }
+ break;
+ // MacData
+ case 3:
+ {
+ CDecPkcs12MacData* theTest = NULL;
+ theTest = CDecPkcs12MacData::NewL(iRawData->Des(),iAuthSafeData->Des());
+ delete theTest;
+ }
+ break;
+ // Attribute
+ case 4:
+ {
+ CDecPkcs12Attribute* theTest = NULL;
+ theTest = CDecPkcs12Attribute::NewL(iRawData->Des());
+ delete theTest;
+ }
+ break;
+ // ShroudedBag
+ case 5:
+ {
+ CDecPkcs12ShroudedKeyBag* theTest = NULL;
+ theTest = CDecPkcs12ShroudedKeyBag::NewL(iRawData->Des());
+ delete theTest;
+ }
+ break;
+ // CertBag
+ case 6:
+ {
+ CDecPkcs12CertBag* theTest = NULL;
+ theTest = CDecPkcs12CertBag::NewL(iRawData->Des());
+ delete theTest;
+ }
+ break;
+ // KeyBag
+ case 7:
+ {
+ CDecPkcs12KeyBag* theTest = NULL;
+ theTest = CDecPkcs12KeyBag::NewL(iRawData->Des());
+ delete theTest;
+ }
+ break;
+ // SafeContentsBag
+ case 8:
+ {
+ CDecPkcs12SafeContentsBag* theTest = NULL;
+ theTest = CDecPkcs12SafeContentsBag::NewL(iRawData->Des());
+ delete theTest;
+ }
+ break;
+ // Safebag/CRL bag
+ case 9:
+ {
+ CDecPkcs12SafeBag* theTest = NULL;
+ theTest = CDecPkcs12SafeBag::NewL(iRawData->Des());
+ delete theTest;
+ }
+ break;
+ // SafeContentsData / SafeContentsEncryptedData
+ case 10:
+ {
+ CDecPkcs12* p12 = NULL;
+ p12 = CDecPkcs12::NewL(iRawData->Des());
+ CleanupStack::PushL(p12);
+
+ const RPointerArray<CPKCS7ContentInfo>& contentInfos = p12->AuthenticatedSafeContents();
+
+ TInt contentInfoCount = contentInfos.Count();
+ for ( TInt index = 0; index < contentInfoCount; index++ )
+ {
+ TInt contentType = contentInfos[index]->ContentType();
+ CDecPkcs12SafeContents* pkcs12SafeContents ;
+ TInt contentTypeData;
+ GetIntFromConfig(ConfigSection(),_L("ContentTypeData"),contentTypeData);
+
+ TInt contentTypeEncryptedData;
+ GetIntFromConfig(ConfigSection(),_L("ContentTypeEncryptedData"),contentTypeEncryptedData);
+
+ if ( contentType == contentTypeEncryptedData )
+ {
+ TPtrC expectedPassword(KNullDesC());
+ GetStringFromConfig(ConfigSection(), _L("Password"), expectedPassword);
+ pkcs12SafeContents = CDecPkcs12SafeContents::NewL(*contentInfos[index],expectedPassword);
+ delete pkcs12SafeContents;
+ }
+ else if ( contentType == contentTypeData )
+ {
+ pkcs12SafeContents = CDecPkcs12SafeContents::NewL(*contentInfos[index]);
+ delete pkcs12SafeContents;
+ }
+ }
+ CleanupStack::PopAndDestroy(p12);
+ break;
+ }
+ }
+ __UHEAP_MARKEND;
+ return TestStepResult();
+ }
+
+/**
+Function is intended to read the data from the specified path.
+@param-aPValue:filepath containing the path of the file
+ retrieved from the ini file.
+@internalTechnology:
+@return:returns data retrieved after reading from the file.
+@test:
+*/
+HBufC8* CTPKCS12OOMStep::ReadFileDataL(TPtrC tag)
+ {
+ TPtrC fileName;
+ if (!GetStringFromConfig(ConfigSection(), tag, fileName))
+ {
+ return NULL;
+ }
+
+ RFile file;
+ if (file.Open(iFs, fileName, EFileRead))
+ {
+ INFO_PRINTF2(_L("Cannot open file %S for reading"), &fileName);
+ return NULL;
+ }
+ CleanupClosePushL(file);
+
+ TInt fileSize = 0;
+ User::LeaveIfError(file.Size(fileSize));
+
+ HBufC8* result = HBufC8::NewL(fileSize);
+ result->Des().SetLength(fileSize);
+
+ TPtr8 rawDataPtr(result->Des());
+ rawDataPtr.SetLength(fileSize);
+ file.Read (rawDataPtr);
+
+ CleanupStack::PopAndDestroy (&file);
+
+ INFO_PRINTF3(_L("Read %d octets from %S"), result->Size(), &fileName);
+
+ return result;
+ }
+
+TVerdict CTPKCS12OOMStep::doTestStepPreambleL()
+ {
+ User::LeaveIfError (iFs.Connect());
+
+ SetTestStepResult(EPass);
+
+ iRawData = ReadFileDataL(_L("File"));
+ if (iRawData == NULL)
+ {
+ INFO_PRINTF1(_L("Failed to read 'File' section of script"));
+ SetTestStepResult(ETestSuiteError);
+ }
+ iAuthSafeData = ReadFileDataL(_L("AuthSafe"));
+ if (iAuthSafeData == NULL)
+ {
+ INFO_PRINTF1(_L("authsafedata file is not required"));
+ }
+ return TestStepResult();
+ }
+/**
+Function is intended to check for the re encoded shrouded key
+@param-aSecName:BagData Section
+@param-aBagData:safebag class pointer
+@internalTechnology:
+@return:returns EFalse if there is a failure else return ETrue
+@test:
+*/
+TBool CPKCS12LibTestStep::ChkEncodedBagValL(TDesC &aSecName,CSafeBagData &aBagData)
+ {
+ TPtrC bagPath(KNullDesC);
+ TBool flagReturn=ETrue;
+
+ //retrieve the shrouded bag value
+ if(!GetStringFromConfig(aSecName,KEncBagValue,bagPath))
+ {
+ ERR_PRINTF1(_L("Not able to get the EncBagValue from the ini file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ TInt fileReturn=0;
+ RFile file;
+
+ if(flagReturn)
+ {
+ fileReturn=file.Open(iFileSession,bagPath,EFileRead);
+
+ if(fileReturn)
+ {
+ ERR_PRINTF1(_L("BagValue:Not able to open the file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ }
+ CleanupClosePushL(file);
+ //raw data for reading the bagvalue
+ HBufC8 *rawData=NULL;
+ TInt filesize=0;
+ if(flagReturn)
+ {
+ User::LeaveIfError(file.Size(filesize));
+ rawData=HBufC8::NewMaxLC(filesize);
+ TPtr8 data(rawData->Des());
+ if(file.Read(data))
+ {
+ ERR_PRINTF1(_L("BagValue:Not able to Read the file"));
+ SetTestStepResult(EFail);
+ flagReturn=EFalse;
+ }
+ }
+ if(flagReturn)
+ {
+ //compare the data
+ if(rawData->CompareC(aBagData.EncodedShroudedKey())!=0)
+ {
+ iActualResult=EFalse;
+ }
+ //retrieve the expected result:PositiveTest/NegativeTest
+ if(!GetBoolFromConfig(aSecName,KExpectedResult,iExpectedResult))
+ {
+ WARN_PRINTF1(_L("ExpectedResult not found in INI file:Default:PositiveTest"));
+ iExpectedResult=KPositiveTest;
+ }
+ //check for positive or negative test
+ if(!VerifyExpectedError(aSecName))
+ {
+ INFO_PRINTF1(_L("BagValue Failed"));
+ SetTestStepResult(EFail);
+ flagReturn = EFalse;
+ }
+ }
+ if(rawData!=NULL)
+ {
+ CleanupStack::PopAndDestroy(rawData);
+ }
+ if(!fileReturn)
+ {
+ file.Close();
+ }
+ CleanupStack::PopAndDestroy(&file);
+ return flagReturn;
+ }