--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoservices/filebasedcertificateandkeystores/test/ttesttools/ttesttoolengine.cpp Wed Jul 08 11:25:26 2009 +0100
@@ -0,0 +1,782 @@
+/*
+* Copyright (c) 2007-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 "ttesttoolengine.h"
+#include <ccertattributefilter.h>
+#include <mctcertstore.h>
+#include <mctkeystore.h>
+
+const TInt swinstalluid = 268452523;
+const TInt swinstallocspuid = 268478646;
+const TInt midletinstalluid = 270506792;
+const TInt tlsuid = 268441661;
+const TInt tocspuid = 268477445;
+
+
+_LIT(KSWInstall, "SWInstall");
+_LIT(KSWInstallOCSP, "SWInstallOCSP");
+_LIT(KMidletInstall, "MidletInstall");
+_LIT(KTls, "SSL/TLS");
+_LIT(KTOcsp, "OCSP Test");
+
+_LIT(KCaType, "ca");
+_LIT(KUserType, "user");
+_LIT(KPeerType, "peer");
+
+
+/*static*/ CTestToolEngine* CTestToolEngine::NewLC()
+ {
+ CTestToolEngine* self = new (ELeave) CTestToolEngine();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ }
+
+CTestToolEngine::CTestToolEngine() : CActive(EPriorityNormal)
+ {
+ iStore = -1;
+ iPolicy = EFalse;
+ }
+
+CTestToolEngine::~CTestToolEngine()
+ {
+ Cancel();
+
+ delete iCertStore;
+ delete iKeyStore;
+
+ delete iFilter;
+ Cancel();
+ iCertInfos.Close();
+ iFsKeyStore.Close();
+ iFs.Close();
+ iUids.Reset();
+ }
+
+void CTestToolEngine::ConstructL()
+ {
+ User::LeaveIfError(iFs.Connect());
+
+ iCertStore = CUnifiedCertStore::NewL(iFs, ETrue);
+
+ User::LeaveIfError(iFsKeyStore.Connect());
+ iKeyStore = CUnifiedKeyStore::NewL(iFsKeyStore);
+
+ // This filter will accept any certificates
+ iFilter = CCertAttributeFilter::NewL();
+
+ CActiveScheduler::Add(this);
+ }
+
+void CTestToolEngine::RunL()
+ {
+ if (iStatus.Int() != KErrNone)
+ {
+ User::Leave(iStatus.Int());
+ }
+
+ switch (iState)
+ {
+ case EInitialiseKeyStore:
+ {
+ // Construct a catch-all filter!
+ iKeyFilter.iKeyAlgorithm = CCTKeyInfo::EInvalidAlgorithm;
+ iKeyFilter.iPolicyFilter = TCTKeyAttributeFilter::EAllKeys;
+ iKeyFilter.iUsage = EPKCS15UsageAll;
+ if (iStore != -1)
+ {
+ MCTKeyStore& chosen = iKeyStore->KeyStore(iStore);
+ chosen.List(iKeys, iKeyFilter, iStatus);
+ }
+ else
+ {
+ iKeyStore->List(iKeys, iKeyFilter, iStatus);
+ }
+ if(iPolicy)
+ {
+ iState = EGetPolicy;
+ }
+ else if (iKeysListCount > 0)
+ {
+ iState = EDone;
+ }
+ else
+ {
+ iState = EFilterKey;
+ }
+ SetActive();
+ }
+ break;
+ case EFilterKey:
+ {
+ TInt index = 0;
+ if (iLabel1.Length())
+ {
+ iNumCert1 = FilterKeys(iKeys, iLabel1, index);
+ }
+ if (iLabel2.Length())
+ {
+ iNumCert2 = FilterKeys(iKeys, iLabel2, index);
+ }
+ CActiveScheduler::Stop();
+ }
+ break;
+ case EInitialise:
+ {
+ if (iStore != -1)
+ {
+ MCTCertStore& chosen = iCertStore->CertStore(iStore);
+ chosen.List(iCertInfos, *iFilter, iStatus);
+ }
+ else
+ {
+ iCertStore->List(iCertInfos, *iFilter, iStatus);
+ }
+
+ if(iAppsCount > 0)
+ {
+ iState = EGetApps;
+ }
+ else if (iGetTrust == 1)
+ {
+ iState = EGetTrust;
+ }
+ else if (iCertsCount > 0)
+ {
+ iState = EDone;
+ }
+ else
+ {
+ iState = EFilter;
+ }
+ SetActive();
+ }
+ break;
+ case EGetPolicy:
+ {
+ FilterKeys(iKeys, iLabel1, iIndex);
+ CActiveScheduler::Stop();
+ }
+ break;
+ case EGetApps:
+ {
+ TInt index = 0;
+ FilterCerts(iCertInfos, iLabel1, index);
+ iCertStore->Applications(*iCertInfos[index], iUids, iStatus);
+ CActiveScheduler::Stop();
+ }
+ break;
+ case EGetTrust:
+ {
+ TInt index = 0;
+ FilterCerts(iCertInfos, iLabel1, index);
+ iCertStore->Trusted(*iCertInfos[index], iActualTrust, iStatus);
+ CActiveScheduler::Stop();
+ }
+ break;
+ case EFilter:
+ {
+ TInt index = 0;
+ TBool filteronly = ETrue;
+ if (iLabel1.Length())
+ {
+ iNumCert1 = FilterCerts(iCertInfos, iLabel1, index, filteronly);
+ }
+ if (iLabel2.Length())
+ {
+ iNumCert2 = FilterCerts(iCertInfos, iLabel2, index, filteronly);
+ }
+ CActiveScheduler::Stop();
+ }
+ break;
+ case EDone:
+ {
+ CActiveScheduler::Stop();
+ }
+ break;
+ default:
+ {
+ User::Panic(_L("Testtool Engine - Illegal state"), 0);
+ }
+ }
+ }
+
+TInt CTestToolEngine::RunError(TInt /*aError*/)
+ {
+ CActiveScheduler::Stop();
+
+ return KErrNone;
+ }
+
+
+void CTestToolEngine::DoCancel()
+ {
+ //CActiveScheduler::Stop();
+ }
+
+TVerdict CTestToolEngine::ListCerts(const TDesC& aLabel1, const TInt aExpectedNumLabel)
+ {
+ TVerdict returnValue = EPass;
+ iLabel1.Set(aLabel1);
+
+ Initilize();
+ if (iNumCert1 != aExpectedNumLabel)
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+
+TVerdict CTestToolEngine::ListCerts(const TDesC& aLabel1, const TDesC& aLabel2, const TInt aExpectedNumLabel)
+ {
+ TVerdict returnValue = EPass;
+ iLabel1.Set(aLabel1);
+ iLabel2.Set(aLabel2);
+
+ Initilize();
+ if (iNumCert1 != aExpectedNumLabel || iNumCert2 != aExpectedNumLabel)
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+TVerdict CTestToolEngine::ListStore(RPointerArray<HBufC>& aCerts)
+ {
+ TVerdict returnValue = EPass;
+ iCertsCount = aCerts.Count();
+
+ Initilize();
+
+ if (!CompareWithExpectedStore(aCerts))
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+TVerdict CTestToolEngine::ListCerts(RPointerArray<HBufC>& aCerts)
+ {
+ TVerdict returnValue = EPass;
+ iCertsCount = aCerts.Count();
+
+ Initilize();
+
+ if (!CompareWithExpectedCertificates(aCerts))
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+TVerdict CTestToolEngine::ListCerts(RPointerArray<HBufC>& aCerts, const TDesC& aLabel)
+ {
+ TVerdict returnValue = EPass;
+ iLabel1.Set(aLabel);
+ iCertsCount = aCerts.Count();
+
+ Initilize();
+ TCertificateOwnerType owner;
+ if (iLabel1.CompareF(KCaType) == KErrNone)
+ {
+ owner = ECACertificate;
+ }
+ else if (iLabel1.CompareF(KUserType) == KErrNone)
+ {
+ owner = EUserCertificate;
+ }
+ else if (iLabel1.CompareF(KPeerType) == KErrNone)
+ {
+ owner = EPeerCertificate;
+ }
+ FilterCerts(iCertInfos, owner);
+ if (!CompareWithExpectedCertificates(aCerts))
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+TVerdict CTestToolEngine::ListCerts(RPointerArray<HBufC>& aCerts, TInt aStore)
+ {
+ TVerdict returnValue = EPass;
+ iStore = aStore;
+ iCertsCount = aCerts.Count();
+
+ Initilize();
+ if (!CompareWithExpectedCertificates(aCerts))
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+TVerdict CTestToolEngine::CheckApps(RPointerArray<HBufC>& aApps, const TDesC& aLabel)
+ {
+ TVerdict returnValue = EPass;
+ iAppsCount = aApps.Count();
+ iLabel1.Set(aLabel);
+ Initilize();
+ if (!VerifyApps(aApps))
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+TVerdict CTestToolEngine::CheckTrust(const TDesC& aLabel,TBool aTrust)
+ {
+ TVerdict returnValue = EPass;
+ iLabel1.Set(aLabel);
+ iGetTrust = 1;
+ Initilize();
+ if (!VerifyTrust(aTrust))
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+TVerdict CTestToolEngine::ListStoreKey(RPointerArray<HBufC>& aKeys)
+ {
+ TVerdict returnValue = EPass;
+ iKeysListCount = aKeys.Count();
+
+ KeyInitilize();
+
+ if (!CompareWithExpectedStoreKey(aKeys))
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+TVerdict CTestToolEngine::ListKeys(const TDesC& aLabel1, const TInt aExpectedNumLabel)
+ {
+ TVerdict returnValue = EPass;
+ iLabel1.Set(aLabel1);
+
+ KeyInitilize();
+ if (iNumCert1 != aExpectedNumLabel)
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+
+TVerdict CTestToolEngine::ListKeys(const TDesC& aLabel1, const TDesC& aLabel2, const TInt aExpectedNumLabel)
+ {
+ TVerdict returnValue = EPass;
+ iLabel1.Set(aLabel1);
+ iLabel2.Set(aLabel2);
+
+ KeyInitilize();
+ if (iNumCert1 != aExpectedNumLabel || iNumCert2 != aExpectedNumLabel)
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+TVerdict CTestToolEngine::ListKeys(RPointerArray<HBufC>& aKeys, TInt aStore)
+ {
+ TVerdict returnValue = EPass;
+ iStore = aStore;
+ iKeysListCount = aKeys.Count();
+
+ KeyInitilize();
+ if (!CompareWithExpectedKeys(aKeys))
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+
+TVerdict CTestToolEngine::ListKeys(RPointerArray<HBufC>& aKeys)
+ {
+ TVerdict returnValue = EPass;
+ iKeysListCount = aKeys.Count();
+
+ KeyInitilize();
+
+ if (!CompareWithExpectedKeys(aKeys))
+ {
+ returnValue = EFail;
+ }
+ return returnValue;
+ }
+
+TVerdict CTestToolEngine::GetPolicy(const TDesC& aLabel1, const TDesC& aLabel2, TInt aUser)
+ {
+ TVerdict returnValue = EPass;
+ iLabel1.Set(aLabel1);
+ iLabel2.Set(aLabel2);
+ iPolicy = ETrue;
+ KeyInitilize();
+ VerifyPolicy(aUser);
+
+ return returnValue;
+ }
+
+void CTestToolEngine::Initilize()
+ {
+ iState = EInitialise;
+ iCertStore->Initialize(iStatus);
+ SetActive();
+ CActiveScheduler::Start();
+ }
+
+void CTestToolEngine::KeyInitilize()
+ {
+ iState = EInitialiseKeyStore;
+ iKeyStore->Initialize(iStatus);
+ SetActive();
+ CActiveScheduler::Start();
+ }
+
+TBool CTestToolEngine::VerifyApps(RPointerArray<HBufC>& aApps)
+ {
+ TInt uidsCount = iUids.Count();
+ TInt appsCount = aApps.Count();
+ TBool result = ETrue;
+ if ( uidsCount != appsCount)
+ {
+ return EFalse;
+ }
+ for (TInt i = 0; i < uidsCount; i++)
+ {
+ if (iUids[i] == TUid::Uid(swinstalluid))
+ {
+ result = CheckAppForUid(KSWInstall, aApps);
+ }
+ else if (iUids[i] == TUid::Uid(swinstallocspuid))
+ {
+ result = CheckAppForUid(KSWInstallOCSP, aApps);
+ }
+ else if (iUids[i] == TUid::Uid(midletinstalluid))
+ {
+ result = CheckAppForUid(KMidletInstall, aApps);
+ }
+ else if (iUids[i] == TUid::Uid(tlsuid))
+ {
+ result = CheckAppForUid(KTls, aApps);
+ }
+ else if (iUids[i] == TUid::Uid(tocspuid))
+ {
+ result = CheckAppForUid(KTOcsp, aApps);
+ }
+ else
+ {
+ result = EFalse;
+ }
+ if (!result)
+ {
+ break;
+ }
+ }
+ return result;
+ }
+
+TBool CTestToolEngine::CheckAppForUid(const TDesC& aAppName, RPointerArray<HBufC>& aApps)
+ {
+ TBool result = EFalse;
+ for (TInt i = 0; i < aApps.Count();i++)
+ {
+ if (aAppName.CompareF(*aApps[i]) == KErrNone)
+ {
+ result = ETrue;
+ break;
+ }
+ else
+ {
+ result = EFalse;
+ }
+ }
+ return result;
+ }
+
+TBool CTestToolEngine::VerifyPolicy(TInt aUser)
+ {
+ TBool result = EFalse;
+ _LIT(KCab, "WriteDeviceData");
+ TLex lex(iLabel2);
+ TUid secid;
+ lex.Val(secid.iUid);
+ TCompiledSecurityPolicy managementPolicy = iKeys[iIndex]->ManagementPolicy();
+ TCompiledSecurityPolicy usePolicy = iKeys[iIndex]->UsePolicy();
+ TUint32 mSecureid = managementPolicy.SecureId();
+ TUint32 uSecureid = usePolicy.SecureId();
+
+ if (aUser == 2)
+ {
+ if (mSecureid == 0xffffffff)
+ {
+ TCapability cab = managementPolicy.Capability(0);
+ // currently only possible for keyowner other than secure id.
+ if (cab == ECapabilityWriteDeviceData && iLabel2.CompareF(KCab) == KErrNone)
+ {
+ result = ETrue;
+ }
+ else
+ {
+ result = EFalse;
+ }
+ }
+ else
+ {
+ TUid mSecureUid = TUid::Uid(mSecureid);
+ if (mSecureUid == secid)
+ {
+ result = ETrue;
+ }
+ else
+ {
+ result = EFalse;
+ }
+ }
+ }
+ else if (aUser == 1)
+ {
+ if (uSecureid == 0xffffffff)
+ {
+ TSecurityPolicy::TType utype = usePolicy.Type();
+ _LIT(KType, "ALL");
+ // currently only possible for keyuser other than secure id
+ if (utype == TSecurityPolicy::ETypePass && iLabel2.CompareF(KType) == KErrNone)
+ {
+ result = ETrue;
+ }
+ else
+ {
+ result = EFalse;
+ }
+ }
+ else
+ {
+ TUid uSecureUid = TUid::Uid(uSecureid);
+ if (uSecureUid == secid)
+ {
+ result = ETrue;
+ }
+ else
+ {
+ result = EFalse;
+ }
+ }
+ }
+ return result;
+ }
+
+TInt CTestToolEngine::FilterCerts(RMPointerArray<CCTCertInfo>& aCertList,
+ TDesC& aLabel, TInt& aIndex, TBool aFilterOnly)
+ {
+ TInt j = 0, count = 0;
+ while (j < aCertList.Count())
+ {
+ if ( aCertList[j]->Label().MatchF(aLabel) != KErrNotFound)
+ {
+ count++;
+ if (count == 1)
+ {
+ //first certificate to be selected for retreiving
+ aIndex = j;
+ }
+ j++;
+ }
+ else
+ {
+ if (!aFilterOnly)
+ {
+ CCTCertInfo* tmp = aCertList[j];
+ tmp->Release();
+ aCertList.Remove(j);
+ }
+ else
+ {
+ j++;
+ }
+ }
+ }
+ return count;
+ }
+
+void CTestToolEngine::FilterCerts(RMPointerArray<CCTCertInfo>& aCertList, TCertificateOwnerType& aOwnerType)
+ {
+ TInt j = 0;
+ while (j < aCertList.Count())
+ {
+ if ( aCertList[j]->CertificateOwnerType() != aOwnerType)
+ {
+ CCTCertInfo* tmp = aCertList[j];
+ tmp->Release();
+ aCertList.Remove(j);
+ }
+ else
+ {
+ j++;
+ }
+ }
+ }
+
+
+TInt CTestToolEngine::FilterKeys(RMPointerArray<CCTKeyInfo>& aKeyList,
+ TDesC& aLabel, TInt& aIndex)
+ {
+ TInt j = 0, count = 0;
+ while (j < aKeyList.Count())
+ {
+ if ( aKeyList[j]->Label().MatchF(aLabel) != KErrNotFound)
+ {
+ count++;
+ if (count == 1)
+ {
+ //first key to be selected for retreiving
+ aIndex = j;
+ }
+ j++;
+ }
+ else
+ {
+ j++;
+ }
+ }
+ return count;
+ }
+
+TBool CTestToolEngine::CompareWithExpectedCertificates(RPointerArray<HBufC>& aCerts)
+ {
+ if ( iCertInfos.Count() != aCerts.Count())
+ {
+ return EFalse;
+ }
+ for (TInt i = 0 ; i < iCertInfos.Count(); i++)
+ {
+ const TDesC& label = iCertInfos[i]->Label();
+ TBool found = EFalse;
+ for (TInt j = 0; j < aCerts.Count(); j++)
+ {
+ if (aCerts[j]->CompareF(label) == KErrNone)
+ {
+ found = ETrue;
+ break;
+ }
+ }
+ if (!found)
+ {
+ return EFalse;
+ }
+ }
+ return ETrue;
+ }
+
+
+TBool CTestToolEngine::CompareWithExpectedKeys(RPointerArray<HBufC>& aKeys)
+ {
+ if ( iKeys.Count() != iKeysListCount)
+ {
+ return EFalse;
+ }
+ for (TInt i = 0 ; i < iKeys.Count(); i++)
+ {
+ const TDesC& label = iKeys[i]->Label();
+ TBool found = EFalse;
+ for (TInt j = 0; j < iKeysListCount; j++)
+ {
+ if (aKeys[j]->CompareF(label) == KErrNone)
+ {
+ found = ETrue;
+ break;
+ }
+ }
+ if (!found)
+ {
+ return EFalse;
+ }
+ }
+ return ETrue;
+ }
+
+TBool CTestToolEngine::CompareWithExpectedStore(RPointerArray<HBufC>& aCerts)
+ {
+ TBool result = EFalse;
+ TInt storeCount = iCertStore->CertStoreCount();
+ for (TInt i = 0; i < storeCount ; i++)
+ {
+ result = EFalse;
+ MCTToken& token = (iCertStore->CertStore(i)).Token();
+ const TDesC& tmp = token.Label();
+ for (TInt j = 0; j < aCerts.Count(); j++)
+ {
+ if (tmp.CompareF(*aCerts[j]) == KErrNone)
+ {
+ result = ETrue;
+ break;
+ }
+ }
+ if (!result)
+ {
+ break;
+ }
+ }
+ return result;
+ }
+
+
+TBool CTestToolEngine::CompareWithExpectedStoreKey(RPointerArray<HBufC>& aKeys)
+ {
+ TBool result = EFalse;
+ TInt storeCount = iKeyStore->KeyStoreCount();
+ for (TInt i = 0; i < storeCount ; i++)
+ {
+ result = EFalse;
+ MCTToken& token = (iKeyStore->KeyStore(i)).Token();
+ const TDesC& tmp = token.Label();
+ for (TInt j = 0; j < aKeys.Count(); j++)
+ {
+ if (tmp.CompareF(*aKeys[j]) == KErrNone)
+ {
+ result = ETrue;
+ break;
+ }
+ }
+ if (!result)
+ {
+ break;
+ }
+ }
+ return result;
+ }
+
+
+
+TBool CTestToolEngine::VerifyTrust(TBool aTrust)
+ {
+ TBool result = EFalse;
+ if (aTrust == iActualTrust)
+ {
+ result = ETrue;
+ }
+ else
+ {
+ result = EFalse;
+ }
+ return result;
+ }