diff -r 000000000000 -r 164170e6151a pkiutilities/CTSecurityDialogs/NotifSrc/CTSecurityDialogsAO.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pkiutilities/CTSecurityDialogs/NotifSrc/CTSecurityDialogsAO.cpp Tue Jan 26 15:20:08 2010 +0200 @@ -0,0 +1,2495 @@ +/* +* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "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 FILES +#include "CTSecurityDialogsAO.h" +#include "CTSecurityDialogNotifier.h" +#include "CTPinQueryDialog.h" +#include "CTSignTextDialog.h" +#include "CTSelectCertificateDialog.h" +#include "CTQueryDialog.h" +#include "CTPinPinQueryDialog.h" +#include "CTNoTrustQuery.h" +#include "CTInvalidCertNote.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// LOCAL CONSTANTS AND MACROS +const TInt KCertArrayGranularity = 3; +const TInt KMaxLengthTextDetailsBody = 5000; +// CertLabel, Issuer, Owner max length 510 bytes +const TInt KMaxLengthTextCertLabel = 510; +// CertLabel, Issuer, Owner max visible length +const TInt KMaxLengthTextCertLabelVisible = 200; +// "dd/mm/yyyy0" +const TInt KMaxLengthTextDateString = 20; +// HH0 +const TInt KMaxLengthTextSerialNumberFormatting = 3; +// Maximum length of a certificate +const TInt KMaxCertificateLength = 5000; + +// Maximum length of key store password +const TInt KMaxKeystorePwLength = 6; + +const TInt KMinImportKeyPwLen = 1; + +const TInt KMaxCNLength = 64; + +_LIT(KCertManUIDetailsViewHexFormat, "%02X"); + +const TInt KFileCertStoreUid( 0x101F501A ); +const TInt KWIMCertStoreUid ( 0x101F79D9 ); +const TUid KTrustedServerTokenUid = { 0x101FB66F }; +const TUid KDeviceCertStoreTokenUid = { 0x101FB668 }; + +_LIT( KBlockSeparator, " " ); +_LIT( KEnter, "\n" ); +_LIT( KEnterEnter, "\n\n" ); +_LIT( KKeyStoreEnterPwLabel, "Key store passphrase" ); +_LIT( KKeyStoreCreatePwLabel, "New key store passphrase" ); +_LIT( KKeyStoreImportKeyLabel, "Passphrase of the imported key file" ); +_LIT( KKeyStoreExportKeyLabel, "Passphrase of the exported key file" ); +_LIT( KPKCS12TokenLabel, "PKCS12"); + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::CCTSecurityDialogsAO +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CCTSecurityDialogsAO::CCTSecurityDialogsAO( CCTSecurityDialogNotifier* aNotifier, + TBool& aDeleted ) : + CActive( EPriorityStandard ), iNotifier( aNotifier ), + iNextStep( EOperationCompleted ), iTrustedSiteCertStore( 0 ), + iHandleIndex( -1 ), iCertPtr( 0, 0 ), iDeleted( aDeleted ) + { + CActiveScheduler::Add( this ); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::ConstructL() + { + iDeleted = EFalse; + + iQueryDialog = NULL; + iQueryDialogDeleted = ETrue; + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CCTSecurityDialogsAO* CCTSecurityDialogsAO::NewL( CCTSecurityDialogNotifier* aNotifier, + TBool& aDeleted ) + { + CCTSecurityDialogsAO* self = new( ELeave ) CCTSecurityDialogsAO( aNotifier, aDeleted ); + + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop(); + + return self; + } + + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::~CCTSecurityDialogsAO +// Destructor +// ----------------------------------------------------------------------------- +// +CCTSecurityDialogsAO::~CCTSecurityDialogsAO() + { + Cancel(); + delete iText; + delete iFilter; + iCertHandleList.Close(); + if ( iCertArray ) + { + //iCertArray->Reset(); // Should we reset this? + //delete iCertArray; + } + iCertInfos.Close(); + if ( iCertInfo ) + { + iCertInfo->Release(); // Should we release this? + } + iKeyInfos.Close(); + if ( iKeyInfo ) + { + iKeyInfo->Release(); // Should we release this? + } + + iServerCerts.ResetAndDestroy(); + delete iCertBuf; + delete iServerName; + delete iCertLabel; + delete iKeyStore; + delete iCertStore; + iFs.Close(); + + iDeleted = ETrue; + } + + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::StartLD() +// Handles all the operations calls appropriate handler functionq +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::StartLD( + const TDesC8& aBuffer, + TInt aReplySlot, + const RMessagePtr2& aMessage ) + { + iOperation = *reinterpret_cast( aBuffer.Ptr() ) & KSecurityDialogOperationMask; + iRetry = *reinterpret_cast( aBuffer.Ptr() ) & EPINValueIncorrect; + iReplySlot = aReplySlot; + iMessagePtr = aMessage; + + WIMSECURITYDIALOGS_WRITE_FORMAT( "CCTSecurityDialogsAO::StartLD iOperation=%d", iOperation ); + + MapTlsProviderOperation( iOperation ); + + switch ( iOperation ) + { + case EEnablePIN: // flow thru + case EDisablePIN: // flow thru + case EEnterPIN: + case EChangePIN: + { + TPINInput PINInput = reinterpret_cast( *aBuffer.Ptr() ); + iPIN = PINInput.iPIN; + DoHandlePinOperationL(); + iStatus = KRequestPending; + SetActive(); + break; + } + case EUnblockPIN: + { + TUnblockPINInput unblockPINInput = reinterpret_cast( *aBuffer.Ptr() ); + iPIN = unblockPINInput.iPIN; + iUnblockPIN = unblockPINInput.iUnblockPIN; + DoHandleUnblockPinOperationL(); + iStatus = KRequestPending; + SetActive(); + break; + } + + case EPINBlocked: + { + TPINInput PINInput = reinterpret_cast( *aBuffer.Ptr() ); + iPIN = PINInput.iPIN; + DoHandleMessageL( EErrorPinCodeBlocked, iPIN.iPINLabel, iPIN.iTokenLabel, 0, 0 ); + iMessagePtr.Complete( KErrNone ); + break; + } + case ETotalBlocked: + { + TPINInput PINInput = reinterpret_cast( *aBuffer.Ptr() ); + iPIN = PINInput.iPIN; + DoHandleMessageL( EErrorPukCodeBlocked, iPIN.iPINLabel, iPIN.iTokenLabel, 0, 0 ); + iMessagePtr.Complete( KErrNone ); + break; + } + case ESignText: + case EUserAuthenticationText: + case EUserAuthentication: + { + iSignInput = reinterpret_cast( *aBuffer.Ptr() ); + DoHandleSignTextL( aBuffer ); + break; + } + case ECreateCSR: + { + DoHandleCSRL( aBuffer.Mid( sizeof(TInt) ) ); + break; + } + case EDeleteCert: + case ECertDetails: + { + DoHandleCertDetailsL( aBuffer.Mid( sizeof(TInt) ) ); + break; + } + case ESaveCert: + { + DoHandleSaveCertL( aBuffer ); + break; + } + case EUnblockPINInClear: + { + User::Leave( KErrNotSupported ); + break; + } + case EPinCodeBlockedInfo: + { + TPtrC8 pinLabelPtr = aBuffer.Mid( sizeof(TInt) + 1 ); + TPINLabel pinLabel; + pinLabel.Copy( pinLabelPtr ); + HBufC* text = iNotifier->LoadResourceStringLC( iOperation, pinLabel ); + + CCTSignTextDialog::RunDlgLD( R_WIM_UNBLOCK_INFO_DIALOG, *text, iStatus, iRetValue ); + CleanupStack::PopAndDestroy( text ); + iStatus = KRequestPending; + SetActive(); + break; + } + case EServerAuthenticationFailure: + { + DoHandleServerAuthFailL( aBuffer ); + break; + } + case MPKIDialog::ESignatureRequested: + { + DoHandleMessageL( EInfoSignTextRequested, KNullDesC, KNullDesC, 1, KMaxTInt ); + iRetValue = ETrue; + HandleResponseAndCompleteL(); + break; + } + case MPKIDialog::ESignatureDone: + { + DoHandleMessageL( EInfoSignTextDone, KNullDesC, KNullDesC, 1, KMaxTInt ); + iRetValue = ETrue; + HandleResponseAndCompleteL(); + break; + } + case MPKIDialog::ESigningCancelled: + { + DoHandleMessageL( EInfoSignTextCancelled, KNullDesC, KNullDesC, 1, KMaxTInt ); + iRetValue = ETrue; + HandleResponseAndCompleteL(); + break; + } + case MPKIDialog::ENoMatchCert: + { + DoHandleMessageL( ENoMatchingPersonalCert, KNullDesC, KNullDesC, 1, KMaxTInt ); + break; + } + case MPKIDialog::ENoSecurityModule: + { + DoHandleMessageL( EErrorWimNotAvailable, KNullDesC, KNullDesC, 1, KMaxTInt ); + iRetValue = ETrue; + HandleResponseAndCompleteL(); + break; + } + case MPKIDialog::EInternalError: + { + DoHandleMessageL( EErrorInternal, KNullDesC, KNullDesC, 1, KMaxTInt ); + iRetValue = ETrue; + HandleResponseAndCompleteL(); + break; + } + case ESaveReceipt: + { + SaveReceiptL( aBuffer.Mid( sizeof(TInt) ) ); + break; + } + default: + User::Panic( _L("CTestSecDlgNotifier"), 0 ); + break; + } + + // Note that CCTSecurityDialogsAO::StartLD() must complete the given message and + // delete itself when ready. However, there may be several steps before it can be + // deleted. CCTSecurityDialogsAO::HandleResponseAndCompleteL() completes the given + // message and deletes CCTSecurityDialogsAO object. Hence, every operation handling + // function called above must call HandleResponseAndCompleteL() when it is ready. + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::DoHandleServerAuthFailL(const TDesC8& aBuffer) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::DoHandleServerAuthFailL( const TDesC8& aBuffer ) + { + CServerAuthenticationFailureInput* srvAuthFail = + CServerAuthenticationFailureInput::NewLC( aBuffer ); + TPtrC8 cert; + TPtrC8 serverName; + + srvAuthFail->GetEncodedCert( cert ); + srvAuthFail->GetServerName( serverName ); + iAuthFailReason = srvAuthFail->FailureReason(); + CleanupStack::PopAndDestroy( srvAuthFail ); + + iServerName = HBufC::NewL( serverName.Length() ); + iServerName->Des().Copy( serverName ); + + HBufC* cn = NULL; + iCertLabel = NULL; + // Site will be checked later. For now it is not trusted + iTrustedSite = EFalse; + + + CX509Certificate* serverCert = CX509Certificate::NewLC( cert ); + // Retrieve subject name + const CX500DistinguishedName& dName = serverCert->SubjectName(); + // Retrieve CN + cn = dName.ExtractFieldL( KX520CommonName ); + if ( cn != NULL ) + { + // commonName exist in the certificate. + // Check the length of CN. RFC 3280 states + // that max length of CN is 64. + if ( cn->Length() <= KMaxCNLength ) + { + iCertLabel = HBufC::NewL( cn->Length() ); + iCertLabel->Des().Append( cn->Des() ); + } + } + + if ( iCertLabel == NULL ) + { + // No or invalid commonName. Use domain name as label + iCertLabel = HBufC::NewL( iServerName->Length() ); + iCertLabel->Des().Append( iServerName->Des() ); + } + + CleanupStack::PopAndDestroy( serverCert ); + + iCertBuf = HBufC8::NewL( cert.Length() ); + *iCertBuf = cert; + + InitCertStoreL(); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::DoHandleCertDetailsL(const TDesC8& aBuffer) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::DoHandleCertDetailsL( const TDesC8& aBuffer ) + { + TCTTokenObjectHandle tokenHandle = + reinterpret_cast( *aBuffer.Ptr() ); + + iTokenHandle.iTokenHandle.iTokenTypeUid = tokenHandle.iTokenHandle.iTokenTypeUid; + iTokenHandle.iTokenHandle.iTokenId = tokenHandle.iTokenHandle.iTokenId; + iTokenHandle.iObjectId = tokenHandle.iObjectId; + + InitCertStoreL(); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::DoHandleSaveCertL(const TDesC8& aBuffer) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::DoHandleSaveCertL( const TDesC8& aBuffer ) + { + TSaveCertInput saveCertInput = + reinterpret_cast( *aBuffer.Ptr() ); + + TInt start = sizeof( TSaveCertInput ); + delete iCertBuf; + iCertBuf = NULL; + iCertBuf = HBufC8::NewL( saveCertInput.iDataSize ); + const TUint8* certPtr = reinterpret_cast( aBuffer.Mid(start).Ptr() ); + iCertBuf->Des().Append( certPtr, saveCertInput.iDataSize ); + ShowCertDialogL(); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::DoHandleCSRL(const TDesC8& aBuffer) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::DoHandleCSRL( const TDesC8& aBuffer ) + { + WIMSECURITYDIALOGS_ENTERFN("CCTSecurityDialogsAO::DoHandleCSRL"); + TInt length = reinterpret_cast( *aBuffer.Ptr() ); + TInt start = sizeof( TInt ) + 1; + iText = HBufC::NewL( length ); + iText->Des().Copy( aBuffer.Mid( start, length ) ); + + start = start + length; + + const TUint8* bufferPtr = aBuffer.Ptr(); + bufferPtr += start; + + TCTTokenObjectHandle tokenHandle; + TCTTokenObjectHandle* tokenHandlePtr = &tokenHandle; + TUint8* copyPtr = reinterpret_cast< TUint8* >( tokenHandlePtr ); + for( TInt i = 0; i < 12; i++ ) + { + copyPtr[ i ] = bufferPtr[ i ]; + } + + iTokenHandle.iTokenHandle.iTokenTypeUid = tokenHandle.iTokenHandle.iTokenTypeUid; + iTokenHandle.iTokenHandle.iTokenId = tokenHandle.iTokenHandle.iTokenId; + iTokenHandle.iObjectId = tokenHandle.iObjectId; + + InitKeyStoreL(); + iNextStep = EGetKeyInfoByHandle; + WIMSECURITYDIALOGS_LEAVEFN("CCTSecurityDialogsAO::DoHandleCSRL"); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::DoHandleSignTextL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::DoHandleSignTextL( const TDesC8& aBuffer ) + { + TInt arraySize = sizeof( TCTTokenObjectHandle ) * iSignInput.iCertHandleArrayTotal; + TInt start = sizeof( TSignInput ); + TInt end = start + arraySize; + for (; start < end; start+=sizeof( TCTTokenObjectHandle )) + { + TCTTokenObjectHandle handle = + reinterpret_cast(*aBuffer.Mid(start).Ptr()); + User::LeaveIfError( iCertHandleList.Append( handle ) ); + } + start = end; + HBufC* textToSign = NULL; + if ( iOperation != EUserAuthentication ) + { + textToSign = HBufC::NewLC( iSignInput.iVariableDataSize / 2 ); // 8 bit -> 16 bit descriptor + //textToSign->Des().Copy(aBuffer.Mid(start)); + const TUint16* textToSignPtr = reinterpret_cast( aBuffer.Mid(start).Ptr() ); + textToSign->Des().Append( textToSignPtr, (iSignInput.iVariableDataSize / 2) ); + } + + if ( iCertHandleList.Count() > 0 ) + { + iNextStep = EOperationSignTextShown; + } + else + { + iNextStep = EOperationCompleted; + iCertHandleList.Close(); + } + switch( iOperation ) + { + case EUserAuthenticationText: + { + CCTSignTextDialog::RunDlgLD( R_WIM_USERAUTHTEXT_DIALOG, + *textToSign, iStatus, iRetValue ); + break; + } + case EUserAuthentication: + { + DoHandleMessageL( EUserAuthentication, KNullDesC, KNullDesC, 1, KMaxTInt ); + break; + } + case ESignText: + { + CCTSignTextDialog::RunDlgLD( R_WIM_SIGNTEXT_DIALOG,*textToSign, iStatus, iRetValue ); + break; + } + default: + { + __ASSERT_DEBUG( EFalse, + _L( "CCTSecurityDialogsAO::DoHandleSignTextL: Invalid operation" ) ); + break; + } + } + iStatus = KRequestPending; + SetActive(); + if ( iOperation == EUserAuthentication ) + { + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + } + else + { + CleanupStack::PopAndDestroy( textToSign ); + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::DoHandleUnblockPinOperationL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::DoHandleUnblockPinOperationL() + { + if ( iRetry ) // Is this new try? + { + // Previous attempt was failed + DoHandleMessageL( EErrorPukCodeIncorrect, KNullDesC, KNullDesC, 0, 0 ); + } + // Ask the PUK code + // The label is iPIN instead of iUnblockPIN, since we need to show to + // the user which PIN to unblock + DoHandleMessageL( EEnterPukNR, iPIN.iPINLabel, + iPIN.iTokenLabel, iUnblockPIN.iMinLength, iUnblockPIN.iMaxLength ); + iNextStep = EEnterNewPIN; + iMultiLineDlgType = EEnterNewPinNR; + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::DoHandlePinOperationL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::DoHandlePinOperationL() + { + if ( iRetry ) // Is this new try? + { + // Previous attempt was failed + DoHandleMessageL( EErrorPinCodeIncorrect, KNullDesC, KNullDesC, 0, 0 ); + } + // Ask the PIN code or PUK code + if ( iPIN.iPINLabel == KKeyStoreEnterPwLabel ) + { + HBufC* header = StringLoader::LoadLC( + R_QTN_CM_HEADING_PHONE_KEYSTORE, CEikonEnv::Static() ); + iPIN.iMinLength = KMaxKeystorePwLength; + DoHandleMessageL( EEnterKeyStorePw, KNullDesC, *header, + iPIN.iMinLength, iPIN.iMaxLength ); + iMultiLineDlgType = EEnterNewKeyStorePw; + CleanupStack::PopAndDestroy( header ); + } + else if ( iPIN.iPINLabel == KKeyStoreImportKeyLabel ) + { + iPIN.iMinLength = KMaxKeystorePwLength; + DoHandleMessageL( EImportKeyPw, KNullDesC, KNullDesC, + KMinImportKeyPwLen, iPIN.iMaxLength ); + iMultiLineDlgType = EEnterNewKeyStorePw; + } + else if ( iPIN.iPINLabel == KKeyStoreExportKeyLabel ) + { + DoHandleMultilinePinQueryL( EExportKeyPw ); + iNextStep = EVerifyPINs; + } + else if ( iPIN.iPINLabel == KKeyStoreCreatePwLabel ) + { + iPIN.iMinLength = KMaxKeystorePwLength; + DoHandleMessageL( EInfoPwCreating, KNullDesC, KNullDesC, 0, 0 ); + DoHandleMultilinePinQueryL( EEnterNewKeyStorePw ); + iNextStep = EVerifyPINs; + } + else if ( iPIN.iTokenLabel == KPKCS12TokenLabel ) + { + DoHandleMessageL( EEnterPw, iPIN.iPINLabel, KNullDesC, + iPIN.iMinLength, iPIN.iMaxLength ); + } + else + { + DoHandleMessageL( EEnterPinNR, iPIN.iPINLabel, iPIN.iTokenLabel, + iPIN.iMinLength, iPIN.iMaxLength ); + iMultiLineDlgType = EEnterNewPinNR; + } + if ( EChangePIN == iOperation ) + { + iNextStep = EEnterNewPIN; + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::DoHandleMultilinePinQueryL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::DoHandleMultilinePinQueryL( const TInt& aDlgType ) + { + iMultiLineDlgType = aDlgType; + HBufC* dlgText1 = NULL; + HBufC* dlgText2 = NULL; + CCTPinPinQueryDialog* dlg = NULL; + TDialogType dlgType = ( TDialogType )aDlgType; + if ( EEnterNewKeyStorePw == dlgType ) + { + dlgText1 = iNotifier->LoadResourceStringLC( dlgType, KNullDesC ); + dlgText2 = iNotifier->LoadResourceStringLC( EVerifyKeyStorePw, KNullDesC ); + dlg = CCTPinPinQueryDialog::NewL( *dlgText1, *dlgText2, iPINValue2, + iPINValueVerify, iPIN.iMinLength, iPIN.iMaxLength, iRetValue ); + dlg->RunDlgLD( iStatus, R_WIM_PWPW_QUERY_DIALOG ); + CleanupStack::PopAndDestroy( 2, dlgText1 ); // dlgText1, dlgText2 + } + else if ( EExportKeyPw == dlgType ) + { + dlgText1 = iNotifier->LoadResourceStringLC( dlgType, KNullDesC ); + dlgText2 = iNotifier->LoadResourceStringLC( EVerifyKeyStorePw, KNullDesC ); + dlg = CCTPinPinQueryDialog::NewL( *dlgText1, *dlgText2, iPINValue2, + iPINValueVerify, iPIN.iMinLength, iPIN.iMaxLength, iRetValue ); + dlg->RunDlgLD( iStatus, R_WIM_PWPW_QUERY_DIALOG ); + CleanupStack::PopAndDestroy( 2, dlgText1 ); // dlgText1, dlgText2 + } + else // Enter new PIN + { + dlgText1 = iNotifier->LoadResourceStringLC( dlgType, iPIN.iPINLabel ); + dlgText2 = iNotifier->LoadResourceStringLC( EVerifyPinNR, iPIN.iPINLabel ); + dlg = CCTPinPinQueryDialog::NewL( *dlgText1, *dlgText2, iPINValue2, + iPINValueVerify, iPIN.iMinLength, iPIN.iMaxLength, iRetValue ); + dlg->RunDlgLD( iStatus, R_WIM_PINPIN_QUERY_DIALOG ); + CleanupStack::PopAndDestroy( 2, dlgText1 ); // dlgText1, dlgText2 + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::DoHandleMessageL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::DoHandleMessageL( + const TInt& aDlgType, + const TDesC& aDynamicText, + const TDesC& aPinQueryHeading, + const TInt aMinLength, + const TInt aMaxLength ) + { + TDialogType dlgType = ( TDialogType )aDlgType; + + HBufC* dlgText = iNotifier->LoadResourceStringLC( dlgType, aDynamicText, aPinQueryHeading ); + + TDialogTypeItem item = iNotifier->GetDialogTypeItem( dlgType ); + + CAknResourceNoteDialog* dlg = NULL; + + TInt resource = 0; + + switch ( item.iNoteType ) + { + case EInfoNote: + { + dlg = new ( ELeave ) CAknInformationNote( ETrue ); + break; + } + + case EErrorNote: + { + dlg = new ( ELeave ) CAknErrorNote( ETrue ); + break; + } + case EConfirmationNote: + { + dlg = new ( ELeave ) CAknConfirmationNote( ETrue ); + break; + } + case EInfoDialog: + { + CCTQueryDialog::RunDlgLD( iStatus, + iRetValue, + *dlgText, item.iSoftKeyResource, + ECTInfoDialog ); + iStatus = KRequestPending; + SetActive(); + break; + } + case EEnterPwPwDialog: + { + CCTPinPinQueryDialog* dialog = + CCTPinPinQueryDialog::NewL( *dlgText, *dlgText, + iPINValue2, iPINValueVerify, aMinLength, aMaxLength, iRetValue ); + dialog->RunDlgLD( iStatus, R_WIM_PWPW_QUERY_DIALOG ); + break; + } + case EEnterPinPinCodeDialog: + { + CCTPinPinQueryDialog* dialog = + CCTPinPinQueryDialog::NewL( *dlgText, *dlgText, + iPINValue2, iPINValueVerify, aMinLength, aMaxLength, iRetValue ); + dialog->RunDlgLD( iStatus, R_WIM_PINPIN_QUERY_DIALOG ); + break; + } + case EEnterPwDialog: + case EEnterPinNRCodeDialog: + case EVerifyPinNRCodeDialog: + { + if ( item.iNoteType == EEnterPwDialog ) + { + resource = R_WIM_PASSWORD_QUERY_DIALOG; + } + else + { + resource = R_WIM_PIN_QUERY_DIALOG; + } + + TPINValue* pinValue = NULL; + switch ( aDlgType ) + { + case EEnterPinNR: // fall thru + case EEnterPukNR: + case EEnterKeyStorePw: + case EImportKeyPw: + { + pinValue = &iPINValue1; + break; + } + case EEnterNewPinNR: + case EEnterNewKeyStorePw: + case EExportKeyPw: + { + pinValue = &iPINValue2; + break; + } + case EVerifyPinNR: + { + pinValue = &iPINValueVerify; + break; + } + default: + { + User::Panic(_L("CSecDlgNotifier"), 0); + } + } + iPinQueryDialogDeleted = EFalse; + CCTPinQueryDialog::RunDlgLD( iStatus, + *dlgText, + *pinValue, + aMinLength, + aMaxLength, + iRetValue, + resource, + iPinQueryDialog, + iPinQueryDialogDeleted ); + break; + } + default: + { + break; + } + + } + + if ( dlg ) + { + dlg->ExecuteLD( *dlgText ); + dlg = NULL; + } + + CleanupStack::PopAndDestroy( dlgText ); // dlgText + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::RunError(TInt aError) +// ?implementation_description +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CCTSecurityDialogsAO::RunError( TInt aError ) + { + iMessagePtr.Complete( aError ); + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::InitCertStoreL() +// ?implementation_description +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::InitCertStoreL() + { + switch(iOperation) + { + case ESignText: + case EUserAuthenticationText: + case EUserAuthentication: + { + iNextStep = EOperationRetrieveCertInfos; + break; + } + case EDeleteCert: + case ECertDetails: + { + iNextStep = EGetCertInfo; + break; + } + case EServerAuthenticationFailure: + { + iNextStep = EProcessTrustedSite;; + break; + } + default: + { + User::Panic( _L("CTestSecDlgNotifier"), 0 ); + } + } + + if ( iCertStore == NULL ) + { + TInt err = KErrNone; + err = iFs.Connect(); + + if( err != KErrNone && err != KErrAlreadyExists ) + { + User::Leave( KErrGeneral ); + } + + iCertStore = CUnifiedCertStore::NewL( iFs, ETrue ); + iCertArray = new (ELeave) CDesCArrayFlat( KCertArrayGranularity ); + iCertStore->Initialize( iStatus ); + iStatus = KRequestPending; + SetActive(); + } + else + { + iStatus = KRequestPending; + SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::InitKeyStoreL() +// ?implementation_description +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::InitKeyStoreL() + { + if ( NULL == iKeyStore ) + { + TInt err = KErrNone; + err = iFs.Connect(); + if( err != KErrNone && err != KErrAlreadyExists ) + { + User::Leave( KErrGeneral ); + } + + iKeyStore = CUnifiedKeyStore::NewL( iFs ); + iKeyStore->Initialize( iStatus ); + iStatus = KRequestPending; + SetActive(); + } + else + { + iStatus = KRequestPending; + SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + } + } +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::GetKeyInfosL() +// ?implementation_description +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::GetKeyInfosL() + { + if ( NULL == iKeyStore ) + { + iStatus = KRequestPending; + SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + } + else + { + iStatus = KRequestPending; + iKeyFilter.iKeyId = iCertInfo->SubjectKeyId(); + iKeyStore->List( iKeyInfos, iKeyFilter, iStatus ); + SetActive(); + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::GetKeyInfoByHandleL() +// ?implementation_description +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::GetKeyInfoByHandleL() + { + if ( NULL == iKeyStore ) + { + User::Panic( _L("CCTSecurityDialogsAO::GetKeyInfoByHandleL()"), 0 ); + } + else + { + iStatus = KRequestPending; + iKeyStore->GetKeyInfo( iTokenHandle, iKeyInfo, iStatus ); + SetActive(); + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::RunL() +// ?implementation_description +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::RunL() + { + WIMSECURITYDIALOGS_WRITE_FORMAT( "CCTSecurityDialogsAO::RunL, iStatus %d", iStatus.Int() ); + WIMSECURITYDIALOGS_WRITE_FORMAT( " iNextStep %d", iNextStep ); + + if ( iStatus != KErrNone ) + { + User::Leave( iStatus.Int() ); + } // if + + switch ( iNextStep ) + { + case EOperationCompleted: + { + WIMSECURITYDIALOGS_WRITE( "EOperationCompleted" ); + HandleResponseAndCompleteL(); + break; + } + case ECheckServerCerts: + { + WIMSECURITYDIALOGS_WRITE( "ECheckServerCerts" ); + + TBool foundCert( EFalse ); + + if ( iServerCerts.Count() ) + { + // Found certificates in the trusted site certificate storage. + // Compare them with the one received from TlsProvider + iCertPtr.Set( iCertBuf->Des() ); + CX509Certificate* serverCert = CX509Certificate::NewLC( iCertPtr ); + + for (TInt i=0; iDes() ); + + CX509Certificate* cert = CX509Certificate::NewLC( certPtr ); + + // Compare fingerprints + if ( cert->Fingerprint() == serverCert->Fingerprint() ) + { + // Fingerprints match + foundCert = ETrue; + } + CleanupStack::PopAndDestroy( cert ); + } + CleanupStack::PopAndDestroy( serverCert ); + if ( foundCert ) + { + // Found matching certificate. Complete the operation + iRetValue = EServerCertAcceptedPermanently; + iNextStep = EOperationCompleted; + HandleResponseAndCompleteL(); + } + } + + if ( !foundCert ) + { + // Couldn't find matching certificate. Prompt user + ShowNoTrustDialogL(); + } + + break; + } + case EProcessTrustedSite: + { + WIMSECURITYDIALOGS_WRITE( "EProcessTrustedSite" ); + TInt count = iCertStore->WritableCertStoreCount(); + for ( TInt i = 0; i < count; i++ ) + { + MCTWritableCertStore *certstore = &iCertStore->WritableCertStore( i ); + MCTToken& token = certstore->Token(); + TUid tokenuid = token.Handle().iTokenTypeUid; + if ( tokenuid == KTrustedServerTokenUid ) + { + iTrustedSiteCertStore = certstore; + } + } + + CTrustSitesStore* trustedSitesStore = CTrustSitesStore::NewL(); + CleanupStack::PushL( trustedSitesStore ); + + // Find out whether or not site associated with certificate is trusted + iTrustedSite = trustedSitesStore->IsTrustedSiteL( *iCertBuf, *iServerName ); + + if ( iTrustedSite ) + { + TBool allowOutOfDate = trustedSitesStore->IsOutOfDateAllowedL(*iCertBuf, *iServerName ); + + if (!allowOutOfDate) + { + CX509Certificate* cert = CX509Certificate::NewLC( iCertBuf->Des() ); + + const CValidityPeriod& validityPeriod = cert->ValidityPeriod(); + const TTime& startValue = validityPeriod.Start(); + const TTime& finishValue = validityPeriod.Finish(); + TTime current; + current.UniversalTime(); + + // First check certificate validity period + if ( ( startValue > current ) || ( finishValue < current ) ) + { + iTrustedSite = EFalse; + } + + CleanupStack::PopAndDestroy(); //cert + } + } + CleanupStack::PopAndDestroy( trustedSitesStore ); // trustedSitesStore + + if ( iTrustedSite ) + { + // Site is trusted. Next step is to check that server + // certificate is in the trusted site certificate storage + iNextStep = ERetrieveServerCerts; + iStatus = KRequestPending; + SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + } + else + { + // Site is not trusted. Prompt user + ShowNoTrustDialogL(); + } + + break; + } + + case ERetrieveServerCerts: + { + WIMSECURITYDIALOGS_WRITE( "ERetrieveServerCerts" ); + if ( iHandleIndex == -1 ) + { + iFilter = CCertAttributeFilter::NewL(); + iFilter->SetOwnerType( EPeerCertificate ); + if ( iTrustedSiteCertStore ) + { + // Thet the list of all certificates from Trusted site certificate + // storage + iTrustedSiteCertStore->List( iCertInfos, *iFilter, iStatus ); + iNextStep = ERetrieveServerCerts; + iStatus = KRequestPending; + SetActive(); + ++iHandleIndex; + } + else + { + // Trusted Site certificate storage doesn't exist + // or something went wrong. + User::Leave( KErrGeneral ); + } + } + else if ( iHandleIndex < iCertInfos.Count() ) + { + iStatus = KRequestPending; + iServerCert = HBufC8::NewL( KMaxCertificateLength ); + iCertPtr.Set( iServerCert->Des() ); + + iTrustedSiteCertStore->Retrieve( *(iCertInfos[iHandleIndex]), iCertPtr, iStatus ); + + iServerCerts.Append( iServerCert ); + + iNextStep = ERetrieveServerCerts; + SetActive(); + ++iHandleIndex; + } + else + { + iNextStep = ECheckServerCerts; + iStatus = KRequestPending; + SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + } + break; + } + case EAddTrustedSite: + { + if ( iStatus.Int() == KErrNone ) + { + //Added server certificate succesfully + CTrustSitesStore* trustedSitesStore = CTrustSitesStore::NewL(); + CleanupStack::PushL( trustedSitesStore ); + + TInt status = trustedSitesStore->AddL( *iCertBuf, *iServerName ); + + CleanupStack::PopAndDestroy( trustedSitesStore ); + if ( status == KErrNone ) + { + iRetValue = EServerCertAcceptedPermanently; + } + else + { + iRetValue = EServerCertNotAccepted; + } + + iNextStep = EOperationCompleted; + HandleResponseAndCompleteL(); + } + else + { + //Adding server certificate failed + iNextStep = EOperationCompleted; + iRetValue = EServerCertNotAccepted; + HandleResponseAndCompleteL(); + } + break; + } + + case ESaveServerCert: + { + WIMSECURITYDIALOGS_WRITE( "ESaveServerCert" ); + DoHandleSaveServerCertL(); + break; + } + case EServerCertCheckUserResp: + { + WIMSECURITYDIALOGS_WRITE( "EServerCertCheckUserResp" ); + if ( iRetValue == EServerCertAcceptedPermanently ) + { + // User accepted to select certificate permanently. + // First add server certificate + iNextStep = ESaveServerCert; + iStatus = KRequestPending; + SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + } + else + { + // User declined or temporarily accepted server certificate + HandleResponseAndCompleteL(); + } + break; + } + case EOperationSignTextShown: + { + if ( iRetValue || iOperation == EUserAuthentication ) + { + iNextStep = EOperationInitCertStore; + } + else + { + iNextStep = EOperationCompleted; + } + iStatus = KRequestPending; + SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + break; + } + case EOperationInitCertStore: + { + TInt err = KErrNone; + err = iFs.Connect(); + if( err != KErrNone && err != KErrAlreadyExists ) + { + User::Leave( KErrGeneral ); + } + + iCertStore = CUnifiedCertStore::NewL( iFs, EFalse ); + iCertArray = new (ELeave) CDesCArrayFlat( KCertArrayGranularity ); + iCertStore->Initialize( iStatus ); + iStatus = KRequestPending; + SetActive(); + iNextStep = EOperationRetrieveCertInfos; + break; + } + case EOperationRetrieveCertInfos: + { + if ( iCertInfo ) + { + iCertArray->AppendL( iCertInfo->Label() ); + iCertInfo = NULL; + } + if ( iHandleIndex == -1 ) + { + iFilter = CCertAttributeFilter::NewL(); + iCertStore->List( iCertInfos, *iFilter, iStatus ); + iNextStep = EOperationRetrieveCertInfos; + iStatus = KRequestPending; + SetActive(); + ++iHandleIndex; + } + else if ( iHandleIndex < iCertHandleList.Count() ) + { + iStatus = KRequestPending; + iCertStore->GetCert( iCertInfo, iCertHandleList[iHandleIndex], iStatus ); + ++iHandleIndex; + iNextStep = EOperationRetrieveCertInfos; + SetActive(); + } + else + { + iHandleIndex = -1; + iNextStep = EOperationSelectCert; + iStatus = KRequestPending; + SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + } + break; + } + case EOperationSelectCert: + { + DoHandleSelectCertificateL(); + break; + } + case EGetCertInfo: + { + iStatus = KRequestPending; + iCertInfo = NULL; + iCertStore->GetCert( iCertInfo, iTokenHandle, iStatus ); + iNextStep = EGetCertificate; + SetActive(); + break; + } + case EGetCertificate: + { + iStatus = KRequestPending; + if ( iCertInfo ) + { + iCertBuf = HBufC8::NewL( KMaxCertificateLength ); + iCertPtr.Set( iCertBuf->Des() ); + iCertStore->Retrieve( *iCertInfo, iCertPtr, iStatus ); + SetActive(); + } + else + { + SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + } + iNextStep = EInitKeyStore; + break; + } + case EInitKeyStore: + { + InitKeyStoreL(); + iNextStep = EGetKeyInfos; + break; + } + case EGetKeyInfos: + { + GetKeyInfosL(); + iNextStep = EShowCertDialog; + break; + } + case EGetKeyInfoByHandle: + { + GetKeyInfoByHandleL(); + iNextStep = EShowCSRDialog; + break; + } + case EShowCSRDialog: + { + ShowCSRDialogL(); + iNextStep = EOperationCompleted; + break; + } + case EShowCertDialog: + { + ShowCertDialogL(); + iNextStep = EOperationCompleted; + break; + } + ///////////// + // PIN steps + ///////////// + case EEnterNewPIN: + { + if ( iRetValue) + { + DoHandleMultilinePinQueryL( iMultiLineDlgType ); + iNextStep = EVerifyPINs; + iStatus = KRequestPending; + SetActive(); + } + else + { + iNextStep = EOperationCompleted; + iPINValue1 = KNullDesC; + iPINValue2 = KNullDesC; + HandleResponseAndCompleteL(); + } + break; + } + + case EVerifyNewPin: + { + if ( iRetValue ) + { + DoHandleMessageL( EVerifyPinNR, iPIN.iPINLabel, iPIN.iTokenLabel, + iPIN.iMinLength, iPIN.iMaxLength ); + iNextStep = EVerifyPINs; + iStatus = KRequestPending; + SetActive(); + } + //Dialog was cancelled by user + else + { + iNextStep = EOperationCompleted; + iPINValue1 = KNullDesC; + iPINValue2 = KNullDesC; + HandleResponseAndCompleteL(); + } + break; + } + case EVerifyPINs: + { + VerifyPinsL(); + break; + } + default: + { + User::Panic( _L("CTestSecDlgNotifier"), 0 ); + } + } + + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::VerifyPinsL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::VerifyPinsL() + { + if ( iRetValue ) + { + if ( iPINValue2 == iPINValueVerify ) + { + HandleResponseAndCompleteL(); + } + else + { + DoHandleMessageL( EErrorCodesDoNotMatch, KNullDesC, KNullDesC, 0, 0 ); + iNextStep = EVerifyPINs; + iPINValue2.Zero(); + iPINValueVerify.Zero(); + DoHandleMultilinePinQueryL( iMultiLineDlgType ); + iStatus = KRequestPending; + SetActive(); + } + } + else + { + iPINValue1 = KNullDesC; + iPINValue2 = KNullDesC; + iNextStep = EOperationCompleted; + HandleResponseAndCompleteL(); + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::DoHandleSelectCertificateL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::DoHandleSelectCertificateL() + { + TBool foundDevCert = EFalse; + + // Check certificate list to find out if there is certificate from + // Device Certificate Store. + for ( TInt ii = 0; ii < iCertHandleList.Count(); ii++) + { + TCTTokenObjectHandle handle = iCertHandleList[ii]; + if ( handle.iTokenHandle.iTokenTypeUid == KDeviceCertStoreTokenUid ) + { + // Found a certificate from Device Certificate Store. + foundDevCert = ETrue; + iTokenHandle = handle; + iRetValue = ETrue; + iNextStep = EOperationCompleted; + iStatus = KRequestPending; + SetActive(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + break; + } + + } + + if ( !foundDevCert ) + { + // No certificate from Device Certificate Store. Prompt user + // for certificate selection + CCTSelectCertificateDialog::RunDlgLD( + iCertArray, iCertHandleList, iTokenHandle, + iStatus, iRetValue ); // Takes ownerhip of array + + iNextStep = EOperationCompleted; + iStatus = KRequestPending; + SetActive(); + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::ShowNoTrustDialogL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::ShowNoTrustDialogL() + { + CX509Certificate* cert = CX509Certificate::NewLC( iCertBuf->Des() ); + TInt resourceid = R_WIM_NO_TRUST_QUERY_UNTRUSTED; + TBool showPermAccept = ETrue; + + if( iAuthFailReason == ESignatureInvalid || iAuthFailReason == ECertificateRevoked ) + { + // Invalid or revoked certificate + CCTInvalidCertificateNote* note = + new( ELeave ) CCTInvalidCertificateNote( *this, iStatus ); + note->ExecuteLD( R_WIM_INVALID_CERTIFICATE_INFORMATION_NOTE ); + iRetValue = EServerCertNotAccepted; + } + else + { + if( iAuthFailReason == EValidatedOK || iAuthFailReason == EDateOutOfRange ) + { + // Trusted certificate, but problems with CN or date + + // Retrieve subject name + const CX500DistinguishedName& dName = cert->SubjectName(); + + // Retrieve common name + HBufC* cn = dName.ExtractFieldL( KX520CommonName ); + + // Check common name first and then date + if( !cn ) + { + // Couldn't retrieve CN from certificate + resourceid = R_WIM_NO_TRUST_QUERY_UNTRUSTED; + } + else if( iServerName->Des() != cn->Des() ) + { + // Domain name doesn't match with CN + resourceid = R_WIM_NO_TRUST_QUERY_SITE; + } + else if( iAuthFailReason == EDateOutOfRange ) + { + // Certificate is out of date + resourceid = R_WIM_NO_TRUST_QUERY_OOD; + showPermAccept = EFalse; + } + else + { + // Otherwise show general untrusted note + resourceid = R_WIM_NO_TRUST_QUERY_UNTRUSTED; + } + } + else + { + // Untrusted certificate + resourceid = R_WIM_NO_TRUST_QUERY_UNTRUSTED; + } + + // No "Accept Permanently" option if certificate is out of date, or + // if domain name is not defined. + const CValidityPeriod& validityPeriod = cert->ValidityPeriod(); + const TTime& startValue = validityPeriod.Start(); + const TTime& finishValue = validityPeriod.Finish(); + TTime current; + current.UniversalTime(); + + if( (( startValue > current ) || ( finishValue < current )) || + ( iServerName->Des().Length() == 0 ) ) + { + showPermAccept = EFalse; + } + + iQueryDialog = new( ELeave ) CCTNoTrustQuery( *this, iRetValue, iStatus, iServerName, + showPermAccept, iQueryDialogDeleted ); + iQueryDialog->ExecuteLD( resourceid ); + } + + CleanupStack::PopAndDestroy( cert ); + + iNextStep = EServerCertCheckUserResp; + iStatus = KRequestPending; + SetActive(); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::ShowCSRDialogL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::ShowCSRDialogL() + { + HBufC* message = HBufC::NewLC( KMaxLengthTextDetailsBody ); + TPtr messagePtr = message->Des(); + + DetailsResourceL( messagePtr, R_QTN_SN_CERT_SIGN_EXPLANATION ); + + messagePtr.Append( KEnter ); + + DetailsFieldDynamicL( messagePtr, *iText, + R_TEXT_RESOURCE_DETAILS_VIEW_SUBJECT, + R_TEXT_RESOURCE_VIEW_NO_SUBJECT_DETAILS ); + + AddKeyUsageL( messagePtr, iKeyInfo ); + AddKeyAlgorithmL( messagePtr, iKeyInfo ); + AddKeySizeL( messagePtr, iKeyInfo ); + AddKeyLocationL( messagePtr, iKeyInfo ); + + CCTSignTextDialog::RunDlgLD( R_WIM_CSR_DIALOG, *message, iStatus, iRetValue ); + CleanupStack::PopAndDestroy( message ); + + iStatus = KRequestPending; + SetActive(); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::ShowCertDialogL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::ShowCertDialogL() + { + CCTKeyInfo* keyInfo = NULL; + if ( 0 < iKeyInfos.Count() ) + { + keyInfo = iKeyInfos[0]; // There should be only one keyInfo. + } + else if ( iKeyInfo ) + { + keyInfo = iKeyInfo; + } + else + { + } + + HBufC* message = NULL; + + if (iOperation == ESaveCert) + { + message = MessageQueryCertDetailsL( *iCertBuf, NULL, iSaveCertInput.iCertFormat, NULL ); + } + else + { + message = MessageQueryCertDetailsL( *iCertBuf, iCertInfo, iCertInfo->CertificateFormat(), keyInfo ); + } + + CleanupStack::PushL( message ); + TInt resource = 0; + switch( iOperation ) + { + case ECertDetails: + { + resource = R_WIM_CERTDETAILS_DIALOG; + break; + } + case ESaveCert: + { + resource = R_WIM_SAVE_CERT_DIALOG; + break; + } + case EDeleteCert: + { + resource = R_WIM_DELETE_CERT_DIALOG; + break; + } + default: + { + User::Panic(_L("CTestSecDlgNotifier"), 0); + } + } + CCTSignTextDialog::RunDlgLD( resource, *message, iStatus, iRetValue ); + CleanupStack::PopAndDestroy( message ); + + iStatus = KRequestPending; + SetActive(); + } + +// --------------------------------------------------------- +// CCertManUICertificateHelper::MessageQueryViewDetailsL(TInt aIndex) +// Creates the whole of certificate details view +// Appends strings from both resources and CertManAPI to one +// message body text and displays it. +// --------------------------------------------------------- +// +HBufC* CCTSecurityDialogsAO::MessageQueryCertDetailsL( + const TDesC8& aCert, + const CCTCertInfo* aCertInfo, + TCertificateFormat aCertFormat, + const CCTKeyInfo* aKeyInfo) + { + // Create message buffer + HBufC* message = HBufC::NewLC( KMaxLengthTextDetailsBody ); + TPtr messagePtr = message->Des(); + // Label + if ( aCertInfo ) + { + DetailsFieldDynamicL( messagePtr, aCertInfo->Label(), + R_TEXT_RESOURCE_DETAILS_VIEW_LABEL, + R_TEXT_RESOURCE_VIEW_NO_LABEL_DETAILS ); + } + + switch ( aCertFormat ) + { + case EX509Certificate: + { + CX509Certificate* cert = CX509Certificate::NewLC( aCert ); + // Let's append all the fields to the message + AddSiteL( messagePtr ); + AddIssuerAndSubjectL( messagePtr, *cert ); + if( aKeyInfo ) + { + AddKeyUsageL( messagePtr, aKeyInfo ); + } + else + { + AddKeyUsageL( messagePtr, *cert ); + } + + AddValidityPeriodL( messagePtr, *cert ); + AddCertLocationL( messagePtr, aCertInfo ); + AddCertFormatL( messagePtr, aCertFormat ); + AddKeyLocationL( messagePtr, aKeyInfo ); + AddCertAlgorithmsL( messagePtr, *cert ); + AddCertSerialNumberL( messagePtr, *cert ); + AddCertFingerprintsL( messagePtr, *cert ); + CleanupStack::PopAndDestroy( cert ); + break; + } + case EX509CertificateUrl: + { + AddKeyUsageL( messagePtr, aKeyInfo ); + + if( aCertInfo ) + { + DetailsFieldDynamicL( messagePtr, aCertInfo->Label(), + R_TEXT_RESOURCE_DETAILS_VIEW_LABEL, + R_TEXT_RESOURCE_VIEW_NO_LABEL_DETAILS ); + } + HBufC* url = HBufC::NewLC( aCert.Length() ); + url->Des().Copy( aCert ); + DetailsFieldDynamicL( messagePtr, *url, + R_TEXT_RESOURCE_DETAILS_VIEW_CERTIFICATE_LOCATION, + R_TEXT_RESOURCE_DETAILS_VIEW_NOT_DEFINED ); + CleanupStack::PopAndDestroy( url ); + AddCertFormatL( messagePtr, aCertFormat ); + AddKeyLocationL( messagePtr, aKeyInfo ); + break; + } + default: + { + User::Leave( KErrNotSupported ); + } + } + + CleanupStack::Pop( message ); + return message; + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddIssuerAndSubjectL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddSiteL( TDes& aMessage ) + { + if ( iServerName ) + { + DetailsFieldDynamicL( aMessage, iServerName->Des(), + R_QTN_CM_SITE, + R_TEXT_RESOURCE_DETAILS_VIEW_NOT_DEFINED ); + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddIssuerAndSubjectL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddIssuerAndSubjectL( TDes& aMessage, const CX509Certificate& aCert ) + { + HBufC* issuer = NULL; + HBufC* owner = NULL; + X509CertNameParser::SubjectFullNameL( aCert, owner ); + CleanupStack::PushL( owner ); + X509CertNameParser::IssuerFullNameL( aCert, issuer ); + CleanupStack::PushL( issuer ); + + DetailsFieldDynamicL( aMessage, issuer->Des(), + R_TEXT_RESOURCE_DETAILS_VIEW_ISSUER, + R_TEXT_RESOURCE_DETAILS_VIEW_NOT_DEFINED ); + CleanupStack::PopAndDestroy( issuer ); //issuer + + // certificate subject + DetailsFieldDynamicL( aMessage, owner->Des(), + R_TEXT_RESOURCE_DETAILS_VIEW_SUBJECT, + R_TEXT_RESOURCE_VIEW_NO_SUBJECT_DETAILS ); + CleanupStack::PopAndDestroy( owner ); //owner + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddKeySizeL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddKeySizeL( TDes& aMessage, const CCTKeyInfo* aKeyInfo ) + { + TUint keySize = aKeyInfo->Size(); + + TBuf sizeBuf; + if ( 0 < keySize ) + { + sizeBuf.AppendNum( keySize, EDecimal ); + } + + DetailsFieldDynamicL( aMessage, sizeBuf, + R_QTN_SN_KEY_LENGTH_LABEL, + R_TEXT_RESOURCE_DETAILS_VIEW_NOT_DEFINED ); + + aMessage.Append( KEnterEnter ); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddKeyUsageL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddKeyUsageL( TDes& aMessage, const CCTKeyInfo* aKeyInfo ) + { + if ( aKeyInfo != NULL ) + { + TKeyUsagePKCS15 keyUsage = aKeyInfo->Usage(); + + TInt usage = 0; + switch( keyUsage ) + { + case EPKCS15UsageSignSignRecover: + case EPKCS15UsageSign: + case EPKCS15UsageSignDecrypt: + usage = R_TEXT_RESOURCE_DETAILS_VIEW_CLIENT_AUTHENTICATION; + break; + case EPKCS15UsageNonRepudiation: + usage = R_TEXT_RESOURCE_DETAILS_VIEW_DIGITAL_SIGNING; + break; + default: + usage = R_TEXT_RESOURCE_DETAILS_VIEW_NOT_DEFINED; + break; + } + DetailsFieldResourceL( aMessage, + R_TEXT_RESOURCE_DETAILS_VIEW_KEY_USAGE, usage); + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddKeyUsageL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddKeyUsageL( TDes& aMessage, const CX509Certificate& aCert ) + { + TKeyUsageX509 x509Usage = EX509UsageNone; + TKeyUsagePKCS15 pkcs15KeyUsage = EPKCS15UsageNone; + const CX509CertExtension* ext = aCert.Extension(KKeyUsage); + if ( ext ) + { + CX509KeyUsageExt* keyUsageExt = + CX509KeyUsageExt::NewLC(ext->Data()); + if ( keyUsageExt->IsSet( EX509DigitalSignature ) ) + { + x509Usage |= EX509UsageDigitalSignature; + } + if ( keyUsageExt->IsSet( EX509NonRepudiation ) ) + { + x509Usage |= EX509UsageNonRepudiation; + } + if ( keyUsageExt->IsSet( EX509KeyEncipherment ) ) + { + x509Usage |= EX509UsageKeyEncipherment; + } + if ( keyUsageExt->IsSet( EX509DataEncipherment ) ) + { + x509Usage |= EX509UsageDataEncipherment; + } + if ( keyUsageExt->IsSet( EX509KeyAgreement ) ) + { + x509Usage |= EX509UsageKeyAgreement; + } + if ( keyUsageExt->IsSet( EX509KeyCertSign ) ) + { + x509Usage |= EX509UsageKeyCertSign; + } + if ( keyUsageExt->IsSet( EX509CRLSign ) ) + { + x509Usage |= EX509UsageCRLSign; + } + if ( keyUsageExt->IsSet( EX509EncipherOnly ) ) + { + x509Usage |= EX509UsageEncipherOnly; + } + if ( keyUsageExt->IsSet( EX509DecipherOnly ) ) + { + x509Usage |= EX509UsageDecipherOnly; + } + CleanupStack::PopAndDestroy( keyUsageExt ); + } + + pkcs15KeyUsage = KeyUsageX509ToPKCS15Private( x509Usage ); + + TInt usage = 0; + switch( pkcs15KeyUsage ) + { + case EPKCS15UsageSignSignRecover: + case EPKCS15UsageSign: + case EPKCS15UsageSignDecrypt: + { + usage = R_TEXT_RESOURCE_DETAILS_VIEW_CLIENT_AUTHENTICATION; + break; + } + case EPKCS15UsageNonRepudiation: + { + usage = R_TEXT_RESOURCE_DETAILS_VIEW_DIGITAL_SIGNING; + break; + } + default: + { + usage = R_TEXT_RESOURCE_DETAILS_VIEW_NOT_DEFINED; + break; + } + + } + DetailsFieldResourceL( aMessage, + R_TEXT_RESOURCE_DETAILS_VIEW_KEY_USAGE, usage ); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddKeyAlgorithmL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddKeyAlgorithmL( TDes& aMessage, const CCTKeyInfo* aKeyInfo ) + { + TInt algRes = 0; + switch( aKeyInfo->Algorithm()) + { + case CKeyInfoBase::ERSA: + { + algRes = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_RSA; + break; + } + case CKeyInfoBase::EDSA: + { + algRes = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_DSA; + break; + } + case CKeyInfoBase::EDH: + { + algRes = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_DH; + break; + } + case CKeyInfoBase::EInvalidAlgorithm: + { + algRes = R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN; + break; + } + default: + { + algRes = R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN; + } + } + DetailsFieldResourceL( aMessage, + R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM, algRes); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddCertLocationL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddCertLocationL( TDes& aMessage, const CCTCertInfo* aCertInfo ) + { + if ( aCertInfo ) + { + AddLocationInfoL( aMessage, aCertInfo->Token().TokenType().Type(), ETrue ); + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddKeyLocationL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddKeyLocationL( TDes& aMessage, const CCTKeyInfo* aKeyInfo ) + { + if ( aKeyInfo ) + { + AddLocationInfoL( aMessage, aKeyInfo->Token().TokenType().Type(), EFalse ); + } + } + +// --------------------------------------------------------- +// CCTSecurityDialogsAO::SetLocationInfo( (HBufC& aMessage, +// TBool aCertificate, +// TUid* aLocUid) +// Adds certificate/private key's location info to certificate details +// --------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddLocationInfoL( + TDes& aMessage, TUid aUid, TBool aCertificate ) + { + TInt location = 0; + TInt locationRes =0; + + switch ( aUid.iUid ) + { + case KFileCertStoreUid: + case KTokenTypeFileKeystore: + { + location = R_TEXT_RESOURCE_DETAILS_VIEW_LOCATION_PHONE_MEMORY; + break; + } + case KWIMCertStoreUid: + { + location = R_TEXT_RESOURCE_DETAILS_VIEW_LOCATION_SMART_CARD; + break; + } + default: + { + if ( aCertificate ) + { + location = R_TEXT_RESOURCE_DETAILS_VIEW_NOT_DEFINED; + } + else + { + location = R_TEXT_RESOURCE_DETAILS_VIEW_NO_PRIVATE_KEY; + } + break; + } + } + + if ( aCertificate ) + { + locationRes = R_TEXT_RESOURCE_DETAILS_VIEW_CERTIFICATE_LOCATION; + } + else + { + locationRes = R_TEXT_RESOURCE_DETAILS_VIEW_PRIVATE_KEY_LOCATION; + } + + DetailsFieldResourceL( aMessage, locationRes, location ); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddValidityPeriodL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddValidityPeriodL( + TDes& aMessage, const CX509Certificate& aCert ) + { + TLocale locale; + TTimeIntervalSeconds offSet = locale.UniversalTimeOffset(); + DetailsResourceL( aMessage, R_TEXT_RESOURCE_DETAILS_VIEW_VALID_FROM ); + const CValidityPeriod& validityPeriod = aCert.ValidityPeriod(); + TTime startValue = validityPeriod.Start(); + startValue += offSet; + TBuf startString; + // read format string from AVKON resource + HBufC* dateFormatString = CEikonEnv::Static()->AllocReadResourceLC( + R_QTN_DATE_USUAL_WITH_ZERO ); + // format the date to user readable format. The format is locale dependent + startValue.FormatL( startString, *dateFormatString ); + AknTextUtils::DisplayTextLanguageSpecificNumberConversion( startString ); + CleanupStack::PopAndDestroy(); // dateFormatString + aMessage.Append( startString ); + aMessage.Append( KEnterEnter ); + + DetailsResourceL( aMessage, R_TEXT_RESOURCE_DETAILS_VIEW_VALID_UNTIL ); + TTime finishValue = validityPeriod.Finish(); + finishValue += offSet; + TBuf finishString; + // read format string from AVKON resource + dateFormatString = CEikonEnv::Static()->AllocReadResourceLC( + R_QTN_DATE_USUAL_WITH_ZERO ); + // format the date to user readable format. The format is locale dependent + finishValue.FormatL( finishString, *dateFormatString ); + AknTextUtils::DisplayTextLanguageSpecificNumberConversion(finishString); + CleanupStack::PopAndDestroy(); // dateFormatString + aMessage.Append( finishString ); + aMessage.Append( KEnterEnter ); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddCertFormatL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddCertFormatL( TDes& aMessage, TCertificateFormat aCertFormat) + { + TInt fieldType = 0; + switch ( aCertFormat ) + { + case EX509CertificateUrl: + case EX509Certificate: + { + fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_CERT_FORMAT_X509; + break; + } + default: + { + fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_NOT_DEFINED; + break; + } + } + DetailsFieldResourceL( aMessage, + R_TEXT_RESOURCE_DETAILS_VIEW_CERT_FORMAT, fieldType ); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddCertAlgorithmsL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddCertAlgorithmsL( TDes& aMessage, const CX509Certificate& aCert ) + { + TInt fieldType = 0; + TInt fieldType2 = 0; + // digest algorithm + TAlgorithmId algorithmId = + aCert.SigningAlgorithm().DigestAlgorithm().Algorithm(); + switch ( algorithmId ) + { + case EMD2: + { + fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_MD2; + break; + } + case EMD5: + { + fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_MD5; + break; + } + case ESHA1: + { + fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_SHA1; + break; + } + default: + { + fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN; + break; + } + } + + // public-key algorithm + algorithmId = + aCert.SigningAlgorithm().AsymmetricAlgorithm().Algorithm(); + switch ( algorithmId ) + { + case ERSA: + { + fieldType2 = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_RSA; + break; + } + case EDSA: + { + fieldType2 = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_DSA; + break; + } + case EDH: + { + fieldType2 = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_DH; + break; + } + default: + { + fieldType2 = R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN; + } + } + + // If other algorithm is unknown + if ( fieldType == R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN || + fieldType2 == R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN ) + { + DetailsFieldResourceL( aMessage, + R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM, R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN ); + } + else // Both are known. + { + DetailsResourceL( aMessage, R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM); + HBufC* stringHolder = StringLoader::LoadLC( fieldType ); + aMessage.Append( stringHolder->Des() ); + CleanupStack::PopAndDestroy(); + stringHolder = StringLoader::LoadLC( fieldType2 ); + aMessage.Append( stringHolder->Des() ); + CleanupStack::PopAndDestroy(); // stringHolder + aMessage.Append( KEnterEnter ); + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddCertSerialNumberL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddCertSerialNumberL( TDes& aMessage, const CX509Certificate& aCert ) + { + // certificate serial number + DetailsResourceL( aMessage, R_TEXT_RESOURCE_DETAILS_VIEW_SERIAL_NUMBER ); + TPtrC8 serialNumber = aCert.SerialNumber(); + TBuf buf2; + + for ( TInt i = 0; i < serialNumber.Length(); i++ ) + { + buf2.Format( KCertManUIDetailsViewHexFormat, serialNumber[i] ); + aMessage.Append( buf2 ); + } + + aMessage.Append( KEnterEnter ); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::AddCertFingerprintsL(...) +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::AddCertFingerprintsL( TDes& aMessage, const CX509Certificate& aCert ) + { + // certificate fingerprint SHA-1 + DetailsResourceL( aMessage, R_TEXT_RESOURCE_DETAILS_VIEW_FINGERPRINT ); + + TPtrC8 sha1_fingerprint = aCert.Fingerprint(); + DevideToBlocks( sha1_fingerprint, aMessage ); + + aMessage.Append( KEnterEnter ); + + // certificate fingerprint MD5 + DetailsResourceL( aMessage, R_TEXT_RESOURCE_DETAILS_VIEW_FINGERPRINT_MD5 ); + + CMD5* md5 = CMD5::NewL(); + CleanupStack::PushL( md5 ); + TBuf8<20> fingerprint = md5->Hash( aCert.Encoding() ); + CleanupStack::PopAndDestroy( md5 ); + + DevideToBlocks( fingerprint, aMessage ); + } + +// --------------------------------------------------------- +// CCTSecurityDialogsAO::DevideToBlocks +// --------------------------------------------------------- +// +void CCTSecurityDialogsAO::DevideToBlocks( const TDesC8& aInput, TDes& aOutput ) + { + const TInt KBlockLength = 2; + TInt blockIndex = 0; + for ( TInt j = 0 ; j < aInput.Length() ; j++ ) + { + if ( blockIndex == KBlockLength ) + { + aOutput.Append( KBlockSeparator ); + blockIndex = 0; + } + aOutput.AppendNumFixedWidthUC( (TUint)(aInput[ j ]), EHex, 2 ); + ++blockIndex; + } + } + +// --------------------------------------------------------- +// CCTSecurityDialogsAO::DetailsFieldResourceL( +// HBufC& aMessage, TInt aResourceOne, TInt aResourceTwo); +// Appends a field that has two strings from resources +// to the details view message body +// --------------------------------------------------------- +// +void CCTSecurityDialogsAO::DetailsFieldResourceL( + TDes& aMessage, TInt aResourceOne, + TInt aResourceTwo ) + { + DetailsResourceL( aMessage, aResourceOne ); + DetailsResourceL( aMessage, aResourceTwo ); + aMessage.Append( KEnter ); + } + +// --------------------------------------------------------- +// CCTSecurityDialogsAO::DetailsFieldDynamicL(HBufC& aMessage, TPtrC aValue, +// TInt aResourceOne, TInt aResourceTwo); +// Appends a field that has string from resources and string from CertManAPI +// to the details view message body +// --------------------------------------------------------- +// +void CCTSecurityDialogsAO::DetailsFieldDynamicL( + TDes& aMessage, + const TDesC& aValue, + TInt aResourceOne, + TInt aResourceTwo) + { + DetailsResourceL( aMessage, aResourceOne ); + DetailsDynamicL( aMessage, aValue, aResourceTwo ); + aMessage.Append( KEnter ); + } + +// --------------------------------------------------------- +// CCTSecurityDialogsAO::DetailsResourceL( +// HBufC& aMessage, TInt aResourceOne); +// Reads line from resources +// --------------------------------------------------------- +// +void CCTSecurityDialogsAO::DetailsResourceL( + TDes& aMessage, TInt aResource) + { + HBufC* stringHolder = StringLoader::LoadLC( aResource ); + aMessage.Append( stringHolder->Des() ); + CleanupStack::PopAndDestroy(); // stringHolder + aMessage.Append( KEnter ); + } + +// --------------------------------------------------------- +// CCTSecurityDialogsAO::DetailsDynamicL( +// HBufC& aMessage, TPtrC aValue, TInt aResourceOne) +// Reads dynamic text, if the string is empty +// put a not defined text from the resource in its place +// KMaxLengthTextCertLabel = 510, used by CertLabel(), Issuer(), Owner() +// --------------------------------------------------------- +// +void CCTSecurityDialogsAO::DetailsDynamicL( + TDes& aMessage, const TDesC& aValue, TInt aResource) + { + HBufC* buf = HBufC::NewLC( KMaxLengthTextCertLabel ); + buf->Des() = aValue; + buf->Des().TrimLeft(); + // Cut CertLabel after fourth semi colon + TPtrC trimmedCertLabel = CutCertificateField( buf->Des() ); + buf->Des().Copy( trimmedCertLabel ); + TInt length = buf->Des().Length(); + if (length == 0 ) + { + DetailsResourceL( aMessage, aResource ); + } + else + { + aMessage.Append( buf->Des() ); + aMessage.Append( KEnter ); + } + CleanupStack::PopAndDestroy(); // buf + } + +// --------------------------------------------------------- +// CCTSecurityDialogsAO::CutCertificateField(TPtrC aField) +// If CertLabel, Issuer and Owner length is over 80 characters, +// cut it down to 80 +// Returns the cut certificate field. +// --------------------------------------------------------- +// +TPtrC CCTSecurityDialogsAO::CutCertificateField( const TDesC& aField ) + { + TInt fieldLength = aField.Length(); + if ( fieldLength >= KMaxLengthTextCertLabelVisible ) + { + TPtrC cutCertLabel = aField.Mid( 0, KMaxLengthTextCertLabelVisible ); + return cutCertLabel; + } + return aField; + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::HandleResponseAndCompleteL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::HandleResponseAndCompleteL() + { + WIMSECURITYDIALOGS_WRITE_FORMAT( "HandleResponseAndCompleteL: %d", iRetValue ); + + MapTlsProviderOperation(iOperation); + + switch (iOperation) + { + case EEnablePIN: // flow thru + case EDisablePIN: // flow thru + case EEnterPIN: + { + TPINValueBuf pinValueBufPtr; + if ( iPIN.iPINLabel == KKeyStoreCreatePwLabel || + iPIN.iPINLabel == KKeyStoreExportKeyLabel ) + { + pinValueBufPtr = iPINValue2; + } + else + { + pinValueBufPtr = iPINValue1; + } + iMessagePtr.WriteL( iReplySlot, pinValueBufPtr ); + break; + } + case EChangePIN: + case EUnblockPIN: + { + TTwoPINOutput twoPINOutput; + twoPINOutput.iPINValueToCheck = iPINValue1; + twoPINOutput.iNewPINValue = iPINValue2; + TTwoPINOutputBuf twoPINOutputBuf( twoPINOutput ); + iMessagePtr.WriteL( iReplySlot, twoPINOutputBuf ); + break; + } + case ESignText: // flow thru + case EUserAuthenticationText: // flow thru + case EUserAuthentication: + { + TCTTokenObjectHandleBuf tokenObjectHandleBuf( iTokenHandle ); + iMessagePtr.WriteL( iReplySlot, tokenObjectHandleBuf ); + break; + } + case EServerAuthenticationFailure: + { + TServerAuthenticationFailureDialogResult result = EStop; + + if ( iRetValue != EServerCertAcceptedPermanently ) + { + if ( iRetValue == EServerCertAcceptedTemporarily ) + { + result = EContinue; + } + else + { + result = EStop; + } + } + else + { + // User permanently accepted server certificate. + result = EContinue; + } + + TServerAuthenticationFailureOutputBuf output( result ); + iMessagePtr.WriteL( iReplySlot, output ); + iMessagePtr.Complete( KErrNone ); + + break; + } + case EPINBlocked: + case EUnblockPINInClear: + { + User::Leave( KErrNotSupported ); + break; + } + case ECreateCSR: + case ECertDetails: + case ESaveCert: + case EDeleteCert: + case ESaveReceipt: + case EPinCodeBlockedInfo: + case MDigSigningNote::ESignatureRequested: + case MDigSigningNote::ESignatureDone: + case MDigSigningNote::ESigningCancelled: + case MDigSigningNote::ENoMatchCert: + case MDigSigningNote::ENoSecurityModule: + case MDigSigningNote::EInternalError: + { + break; // Complete is enough + } + default: + User::Panic( _L("CTestSecDlgNotifier"), 0 ); + } + + if( iOperation != EServerAuthenticationFailure ) + { + iMessagePtr.Complete( iRetValue ? KErrNone : KErrCancel ); + } + + delete this; + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::SaveReceiptL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::SaveReceiptL( const TDesC8& aBuffer ) + { + TInt size = reinterpret_cast( *aBuffer.Ptr() ); + TInt start = sizeof(TInt) + 1; + HBufC* signedText = HBufC::NewLC( size ); + signedText->Des().Copy( aBuffer.Mid(start) ); + CEikProcess* process = CEikonEnv::Static()->Process(); + CDocumentHandler* docHandler = CDocumentHandler::NewLC( process ); + _LIT8( KPlainText, "text/plain" ); + TDataType dataType( KPlainText ); + // convert 16->8bits + HBufC8* content = HBufC8::NewLC( signedText->Length() ); + content->Des().Copy( *signedText ); + + docHandler->SaveL( *content, + dataType, + KEntryAttNormal); + + CleanupStack::PopAndDestroy( 3, signedText ); // content, docHandler, signedText + HandleResponseAndCompleteL(); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::DoCancel() +// ?implementation_description +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::DoCancel() + { + WIMSECURITYDIALOGS_WRITE( "CCTSecurityDialogsAO::DoCancel" ); + + // Note that iQueryDialog may point to already deleted memory. + // Dialogs need to set and reset iQueryDialogDeleted flag to + // allow deleting the dialog from CCTSecurityDialogsAO. + if( !iQueryDialogDeleted ) + { + delete iQueryDialog; + iQueryDialogDeleted = ETrue; + } + iQueryDialog = NULL; + + if ( !iPinQueryDialogDeleted ) + { + delete iPinQueryDialog; + iPinQueryDialogDeleted = ETrue; + } + iPinQueryDialog = NULL; + + // Complete message if it has not been completed earlier. + if( !iMessagePtr.IsNull() ) + { + iMessagePtr.Complete( KErrCancel ); + } + } + +// For server authentication failure +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::CreateMessageLC() +// ----------------------------------------------------------------------------- + +HBufC* CCTSecurityDialogsAO::CreateMessageL() + { + //TPtrC8 certPtrC; + //iSrvAuthFail->GetEncodedCert(certPtrC); + return MessageQueryCertDetailsL( + *iCertBuf, NULL, EX509Certificate, NULL ); + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::DoHandleSaveServerCertL() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::DoHandleSaveServerCertL() + { + if ( iTrustedSiteCertStore ) + { + iTrustedSiteCertStore->Add( *iCertLabel, EX509Certificate, + EPeerCertificate, NULL, NULL, *iCertBuf, iStatus ); + + // Next step is to update trust site db + iNextStep = EAddTrustedSite; + iStatus = KRequestPending; + SetActive(); + } + } + +// ----------------------------------------------------------------------------- +// CCTSecurityDialogsAO::MapTlsProviderOperation() +// ----------------------------------------------------------------------------- +// +void CCTSecurityDialogsAO::MapTlsProviderOperation( TUint aOperation ) + { + switch (aOperation) + { + case ESecureConnection: + { + iOperation = EUserAuthentication; + break; + } + default: + break; + } + } +