--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoservices/filebasedcertificateandkeystores/test/thwkeystore/client/thwkeystoreclient.cpp Mon Oct 12 10:17:04 2009 +0300
@@ -0,0 +1,503 @@
+/*
+* Copyright (c) 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:
+* Contains the implementation of CHardwareKeyStoreClient. In this
+* class only the newly added APIs for WMDRM have been implemented.
+* So this is not a full functional crypto token.
+*
+*/
+
+
+#include "thwkeystoreclient.h"
+#include "thwkeystoredefs.h"
+#include "keys.h"
+#include <cryptospi/cryptospidef.h>
+#include "cryptoasymmetriccipherapi.h"
+#include "cryptosignatureapi.h"
+#include <s32mem.h>
+
+MCTTokenInterface* CHardwareKeyStoreClient::NewKeyStoreInterfaceL(MCTToken& aToken)
+ {
+ // Destroyed by MCTTokenInterface::DoRelease()
+ CHardwareKeyStoreClient* me = new (ELeave) CHardwareKeyStoreClient(aToken);
+ CleanupStack::PushL(me);
+ me->ConstructL();
+ CleanupStack::Pop(me);
+ return (me);
+ }
+
+CHardwareKeyStoreClient::CHardwareKeyStoreClient(MCTToken& aToken)
+ : CActive(EPriorityNormal),
+ // Reference count starts at one as we're always created and returned by a GetInterface() call on the token
+ iRefCount(1),
+ iToken(aToken)
+ {
+ }
+
+void CHardwareKeyStoreClient::ConstructL()
+ {
+ CActiveScheduler::Add(this);
+ iCryptoTokenHai = CCryptoTokenHai::NewL(&iToken);
+ }
+
+CHardwareKeyStoreClient::~CHardwareKeyStoreClient()
+ {
+ Cancel();
+ delete iCryptoTokenHai;
+ }
+
+MCTToken& CHardwareKeyStoreClient::Token()
+ {
+ return iToken;
+ }
+
+void CHardwareKeyStoreClient::AddRef()
+ {
+ ++iRefCount;
+
+ iToken.AddRef();
+ }
+
+void CHardwareKeyStoreClient::DoRelease()
+ {
+ --iRefCount;
+
+ ASSERT(iRefCount >= 0);
+ if (iRefCount == 0)
+ {
+ MCTTokenInterface::DoRelease();
+ }
+ }
+
+void CHardwareKeyStoreClient::ReleaseObject(const TCTTokenObjectHandle& /*aHandle*/)
+ {
+ }
+
+void CHardwareKeyStoreClient::RunL()
+ {
+ User::LeaveIfError(iStatus.Int());
+
+ switch(iState)
+ {
+ case ECreateSigner:
+ {
+ if(iCryptoTokenHai->KeyPresent(iHandle.iObjectId) != KErrNotFound)
+ {
+ CryptoSpi::TKeyProperty keyProperty;
+ keyProperty.iAlgorithmUid = CryptoSpi::KEccSignerUid;
+
+ CryptoSpi::CCryptoParams* keyParameters = CryptoSpi::CCryptoParams::NewLC();
+ keyParameters->AddL(iHandle.iObjectId, CryptoSpi::KPassedHandleToKeyUid);
+ CryptoSpi::CKey* newKey = CryptoSpi::CKey::NewL(keyProperty, *keyParameters);
+ CleanupStack::PushL(newKey);
+
+ CryptoSpi::CSignatureFactory::CreateSignerL( *(iClientBuffer.iSigner), CryptoSpi::KEccSignerUid,
+ *newKey, CryptoSpi::KPaddingModeNoneUid,
+ NULL );
+
+ CleanupStack::PopAndDestroy(newKey);
+ CleanupStack::PopAndDestroy(keyParameters);
+ }
+ else
+ {
+ User::Leave(KErrNotFound);
+ }
+ }
+ break;
+ case ECreateAsymmetricCipher:
+ {
+ if(iCryptoTokenHai->KeyPresent(iHandle.iObjectId) != KErrNotFound)
+ {
+ CryptoSpi::TKeyProperty keyProperty;
+ keyProperty.iAlgorithmUid = CryptoSpi::KEccCipherUid;
+
+ CryptoSpi::CCryptoParams* keyParameters = CryptoSpi::CCryptoParams::NewLC();
+ keyParameters->AddL(iHandle.iObjectId, CryptoSpi::KPassedHandleToKeyUid);
+ CryptoSpi::CKey* newKey = CryptoSpi::CKey::NewL(keyProperty, *keyParameters);
+ CleanupStack::PushL(newKey);
+
+ CryptoSpi::CAsymmetricCipherFactory::CreateAsymmetricCipherL(
+ *(iClientBuffer.iAsymmetricCipher), CryptoSpi::KEccCipherUid,
+ *newKey, CryptoSpi::KCryptoModeDecryptUid,
+ CryptoSpi::KPaddingModeNoneUid, NULL);
+
+ CleanupStack::PopAndDestroy(newKey);
+ CleanupStack::PopAndDestroy(keyParameters);
+ }
+ else
+ {
+ User::Leave(KErrNotFound);
+ }
+ }
+ break;
+ case EDecryptInHardware:
+ {
+ if(iCryptoTokenHai->KeyPresent(iHandle.iObjectId) != KErrNotFound)
+ {
+ iCryptoTokenHai->DecryptL(iHandle.iObjectId, *iPtr, *(iClientBuffer.decryptedText));
+ }
+ else
+ {
+ User::Leave(KErrNotFound);
+ }
+ }
+ break;
+ case ESignInHardware:
+ {
+ if(iCryptoTokenHai->KeyPresent(iHandle.iObjectId) != KErrNotFound)
+ {
+ HBufC8* signature;
+ iCryptoTokenHai->SignL(iHandle.iObjectId, *iPtr, signature);
+ CleanupStack::PushL(signature);
+ iClientBuffer.iSignature->AddL(signature->Des(), CryptoSpi::KEccKeyTypeUid);
+ CleanupStack::PopAndDestroy(signature);
+ }
+ else
+ {
+ User::Leave(KErrNotFound);
+ }
+ break;
+ }
+
+ case EExportKey:
+ {
+ if(iCryptoTokenHai->KeyPresent(iHandle.iObjectId) != KErrNotFound)
+ {
+ iCryptoTokenHai->ExportPublicKeyL(iHandle.iObjectId, *iPublicKey);
+ }
+ else
+ {
+ User::Leave(KErrNotFound);
+ }
+ break;
+ }
+ default:
+ User::Leave(KErrArgument);
+ }
+
+ User::RequestComplete(iClientStatus,KErrNone);
+ }
+
+void CHardwareKeyStoreClient::DoCancel()
+ {
+ User::RequestComplete(iClientStatus,KErrCancel);
+ }
+
+TInt CHardwareKeyStoreClient::RunError(TInt aError)
+ {
+ User::RequestComplete(iClientStatus, aError);
+ return KErrNone;
+ }
+
+/*
+ * MKeystore interfaces
+ */
+
+void CHardwareKeyStoreClient::List(
+ RMPointerArray<CCTKeyInfo>& aKeys,
+ const TCTKeyAttributeFilter& aFilter,
+ TRequestStatus& aStatus)
+ {
+ iClientStatus = &aStatus;
+ *iClientStatus = KRequestPending;
+ TRequestStatus* status = &aStatus;
+ TRAPD(err,iCryptoTokenHai->ListL(aFilter,aKeys));
+ User::RequestComplete(status, err);
+ }
+
+void CHardwareKeyStoreClient::CancelList()
+ {
+
+ }
+
+void CHardwareKeyStoreClient::GetKeyInfo(TCTTokenObjectHandle /*aHandle*/, CCTKeyInfo*& /*aInfo*/,
+ TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::CancelGetKeyInfo()
+ {
+ // synchronous, nothing to do
+ }
+
+void CHardwareKeyStoreClient::Open(const TCTTokenObjectHandle& /*aHandle*/,
+ MRSASigner*& /*aSigner*/,
+ TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::Open(const TCTTokenObjectHandle& /*aHandle*/,
+ MCTSigner<CDSASignature*>*& /*aSigner*/,
+ TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::Open(const TCTTokenObjectHandle& /*aHandle*/,
+ MCTDecryptor*& /*aDecryptor*/,
+ TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::Open(const TCTTokenObjectHandle& /*aHandle*/,
+ MCTDH*& /*aDH*/, TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::CancelOpen()
+ {
+ // synchronous, nothing to do
+ }
+
+/** Returns the public key in DER-encoded ASN-1 */
+void CHardwareKeyStoreClient::ExportPublic(const TCTTokenObjectHandle& aHandle,
+ HBufC8*& aPublicKey,
+ TRequestStatus& aStatus)
+ {
+ //TRequestStatus* status = &aStatus;
+ iClientStatus = &aStatus;
+
+ iStatus = KRequestPending;
+ *iClientStatus = KRequestPending;
+ iPublicKey = &aPublicKey;
+ iHandle = aHandle;
+ TRequestStatus* status = &iStatus;
+ SetActive();
+ iState = EExportKey;
+
+ User::RequestComplete(status, KErrNone);
+ }
+
+void CHardwareKeyStoreClient::CancelExportPublic()
+ {
+ // synchronous, nothing to do
+ }
+
+// *********************************************************************************
+// MCTKeyStoreManager
+// *********************************************************************************
+void CHardwareKeyStoreClient::CreateKey(CCTKeyInfo*& /*aReturnedKey*/, TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::CancelCreateKey()
+ {
+ }
+
+/**
+ * This function is not implemented since in the WMDRM case, device
+ * are preprovisioned inside the device. Hence implementing this
+ * function is not required.
+ */
+void CHardwareKeyStoreClient::ImportKey(const TDesC8& /*aKey*/, CCTKeyInfo*& /*aReturnedKey*/, TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::CancelImportKey()
+ {
+ }
+
+void CHardwareKeyStoreClient::ImportEncryptedKey(const TDesC8& /*aKey*/, CCTKeyInfo*& /*aReturnedKey*/, TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::CancelImportEncryptedKey()
+ {
+ }
+
+void CHardwareKeyStoreClient::ExportKey(TCTTokenObjectHandle /*aHandle*/, HBufC8*& /*aKey*/, TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::CancelExportKey()
+ {
+ }
+
+void CHardwareKeyStoreClient::ExportEncryptedKey(TCTTokenObjectHandle /*aHandle*/, const CPBEncryptParms& /*aParams*/, HBufC8*& /*aKey*/, TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::CancelExportEncryptedKey()
+ {
+ }
+
+void CHardwareKeyStoreClient::DeleteKey(TCTTokenObjectHandle /*aHandle*/, TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::CancelDeleteKey()
+ {
+ // synchronous, nothing to do
+ }
+
+void CHardwareKeyStoreClient::SetUsePolicy(TCTTokenObjectHandle /*aHandle*/,
+ const TSecurityPolicy& /*aPolicy*/,
+ TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::CancelSetUsePolicy()
+ {
+ // synchronous, nothing to do
+ }
+
+void CHardwareKeyStoreClient::SetManagementPolicy(TCTTokenObjectHandle /*aHandle*/,
+ const TSecurityPolicy& /*aPolicy*/,
+ TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNotSupported);
+ }
+
+void CHardwareKeyStoreClient::CancelSetManagementPolicy()
+ {
+ // synchronous, nothing to do
+ }
+
+/**
+ * @todo
+ * This interface should return KErrNotSupported but because of the way
+ * it has been implemented in unifiedkeystore this is returning
+ * KErrNone. This should be fixed later.
+ */
+void CHardwareKeyStoreClient::SetPassphraseTimeout(TInt /*aTimeout*/, TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNone);
+ }
+
+void CHardwareKeyStoreClient::CancelSetPassphraseTimeout()
+ {
+ // No point cancelling, not asynchronous
+ }
+
+/**
+ * @todo
+ * This interface should return KErrNotSupported but because of the way
+ * it has been implemented in unifiedkeystore this is returning
+ * KErrNone. This should be fixed later.
+ */
+void CHardwareKeyStoreClient::Relock(TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNone);
+ }
+
+void CHardwareKeyStoreClient::CancelRelock()
+ {
+ // No point cancelling, not asynchronous
+ }
+
+
+void CHardwareKeyStoreClient::Open( const TCTTokenObjectHandle& aHandle,
+ CryptoSpi::CSigner*& aSigner,
+ TRequestStatus& aStatus )
+ {
+ iClientStatus = &aStatus;
+ iStatus = KRequestPending;
+ *iClientStatus = KRequestPending;
+ iClientBuffer.iSigner = &aSigner;
+ iHandle = aHandle;
+ TRequestStatus* status = &iStatus;
+ SetActive();
+ iState = ECreateSigner;
+ User::RequestComplete(status, KErrNone);
+ }
+
+void CHardwareKeyStoreClient::Open( const TCTTokenObjectHandle& aHandle,
+ CryptoSpi::CAsymmetricCipher*& aAsymmetricCipher,
+ TRequestStatus& aStatus )
+ {
+ iClientStatus = &aStatus;
+ iStatus = KRequestPending;
+ *iClientStatus = KRequestPending;
+ iClientBuffer.iAsymmetricCipher = &aAsymmetricCipher;
+ iHandle = aHandle;
+ TRequestStatus* status = &iStatus;
+ SetActive();
+ iState = ECreateAsymmetricCipher;
+ User::RequestComplete(status, KErrNone);
+ }
+
+
+void CHardwareKeyStoreClient::Decrypt( const TCTTokenObjectHandle& aHandle,
+ const TDesC8& aCiphertext,
+ HBufC8*& aPlaintextPtr,
+ TRequestStatus& aStatus )
+ {
+ iClientStatus = &aStatus;
+ iStatus = KRequestPending;
+ *iClientStatus = KRequestPending;
+ iHandle = aHandle;
+ iPtr = &aCiphertext;
+ iClientBuffer.decryptedText = &aPlaintextPtr;
+ TRequestStatus* status = &iStatus;
+ SetActive();
+ iState = EDecryptInHardware;
+ User::RequestComplete(status, KErrNone);
+ }
+
+void CHardwareKeyStoreClient::Sign( const TCTTokenObjectHandle& aHandle,
+ const TDesC8& aPlaintext,
+ CryptoSpi::CCryptoParams*& aSignature,
+ TRequestStatus& aStatus )
+ {
+ iClientStatus = &aStatus;
+ iStatus = KRequestPending;
+ *iClientStatus = KRequestPending;
+ iHandle = aHandle;
+ iPtr = &aPlaintext;
+ iClientBuffer.iSignature = aSignature;
+ TRequestStatus* status = &iStatus;
+ SetActive();
+ iState = ESignInHardware;
+ User::RequestComplete(status, KErrNone);
+ }
+
+
+void CHardwareKeyStoreClient::ImportKey( TPtr /* aLabel */,
+ TPtr8 /* aPrivateKey */, TPtr8 /* aPublicKey */ ,
+ TRequestStatus& aStatus)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, KErrNone);
+ }
+
+
+
+
+