diff -r 000000000000 -r 62f9d29f7211 webservices/wsidentitymanager/src/senbaseidentity.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webservices/wsidentitymanager/src/senbaseidentity.cpp Thu Jan 07 16:19:19 2010 +0200 @@ -0,0 +1,989 @@ +/* +* Copyright (c) 2002-2005 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 +#include +#include +#include // WSF error codes + +#include "senbaseidentity.h" +#include "senwiseidentityprovider.h" +#include "sendebug.h" // internal Utils\inc - filelogging MACROs +#ifdef __CRYPTO_HW__ +#include "sencryptoutils.h" +#include +#include +#include +#include +const TInt KCryptoPADataLen = 16; +const TInt KCryptoPACipherLen = 48; +const TInt KPaCryptAuthLen = 32; +const TInt KEncryptNoSalt = 3; +const TInt KDecrypt = 2; +const TUint KPadding = 0; +const TUint KEncrypedLen = 128; +_LIT8(KCryptoPA, "PA_CRYPT"); + +#endif // __CRYPTO_HW__ + +EXPORT_C CSenBaseIdentity* CSenBaseIdentity::NewL(TPtrC8 aIMEI) + { + CSenBaseIdentity* pNew = NewLC(aIMEI); + CleanupStack::Pop(); + return(pNew) ; + } +EXPORT_C CSenBaseIdentity* CSenBaseIdentity::NewLC(TPtrC8 aIMEI) + { + CSenBaseIdentity* pNew = new (ELeave) CSenBaseIdentity(aIMEI); + CleanupStack::PushL(pNew); + pNew->ConstructL(); + return pNew; + } +CSenBaseIdentity::CSenBaseIdentity(TPtrC8 aIMEI) +: iProvider(NULL), + iIMEI(aIMEI) + { + } + +void CSenBaseIdentity::ConstructL() + { + BaseConstructL( KIdentityElementLocalName() ); + } + + +CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL(MSenServiceDescription& aService ) + { + + TInt idpCount(iProviderList.Count()); + + CSenIdentityProvider* pIdp = NULL; + CSenIdentityProvider* pCandidate = NULL; + + for (TInt i=0; iIsTrustedByL(aService)) + { + pIdp = pCandidate; + pCandidate = NULL; + } + if(pIdp == NULL && pCandidate->IsDefault()) + { + pIdp = pCandidate; + } + + if(pIdp) + { + break; + } + } + return pIdp; + } + +CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL(const TDesC8& aURI ) + { + TInt idpCount(iProviderList.Count()); + CSenIdentityProvider* retVal = NULL; + for (TInt i=0; iEndpoint() == aURI) + { + break; + } + else + { + retVal = NULL; + } + } + return retVal; + } + +CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL(const CDesC8Array& aIdpIdList, + TBool aStrict ) + { + TInt idpCount(iProviderList.Count()); + TInt patternCount(aIdpIdList.Count()); + + if(patternCount==0) + { + if(aStrict) + { + return NULL; + } + else + { + return IdentityProviderL(); // return the default provider + } + } + + // to optimize the search, store the default idp + CSenIdentityProvider* pDefault = NULL; + + for (TInt i=0; iProviderID(); + if(providerID.Length()>0 && providerID == aIdpIdList[j]) + { + return (CSenIdentityProvider*)iProviderList[i]; + } + } + if(!aStrict) + { + // to optimize the search, store the default idp, if found + if(((CSenIdentityProvider*)iProviderList[i])->IsDefault()) + { + pDefault = (CSenIdentityProvider*)iProviderList[i]; + } + } + } + if(aStrict) + { + // default idp does not meet the search requirements + // (not in strict pattern list) + return NULL; + } + else + { + // if current item did not match with anything in the + // pattern list, check if it's ok in non-strict perspective + return pDefault; + } + } + +CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL(MSenServiceDescription& aService, + const CDesC8Array& aIdpIdList, + TBool aStrict) + { + TInt idpCount(iProviderList.Count()); + TInt patternCount(aIdpIdList.Count()); + + if(patternCount==0) + { + if(aStrict) + { + return NULL; + } + else + { + return IdentityProviderL(); // return the default provider + } + } + + // to optimize the search, store the default idp + CSenIdentityProvider* pDefault = NULL; + CSenIdentityProvider* pTrusted = NULL; + + for (TInt i=0; iProviderID(); + if(providerID.Length()>0 && providerID == aIdpIdList[j]) + { + if (((CSenIdentityProvider*)iProviderList[i])->IsTrustedByL(aService)) + { + return (CSenIdentityProvider*)iProviderList[i]; + } + } + } + + if(!aStrict) + { + if (!pTrusted) + { + if (((CSenIdentityProvider*)iProviderList[i])->IsTrustedByL(aService)) + { + pTrusted = (CSenIdentityProvider*)iProviderList[i]; + } + } + + // to optimize the search, store the default IDP, if found + if(((CSenIdentityProvider*)iProviderList[i])->IsDefault()) + { + pDefault = (CSenIdentityProvider*)iProviderList[i]; + } + } + } + + + if(aStrict) + { + // default idp does not meet the search requirements + // (not in strict pattern list) + return NULL; + } + else + { + // if current item did not match with anything in the + // pattern list, check if it's ok in non-strict perspective + if (pTrusted) + { + return pTrusted; + } + else + { + return pDefault; + } + } + } + +CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL() + { + TInt idpCount(iProviderList.Count()); + + CSenIdentityProvider* pDefaultIdp = NULL; + + for (TInt i=0; iIsDefault()) pDefaultIdp = NULL; + } + + if (!pDefaultIdp && idpCount > 0) + { + // use the first IdentityProvider + pDefaultIdp = (CSenIdentityProvider*)iProviderList[0]; + } + + return pDefaultIdp; + } +const RIdentityProviderList& CSenBaseIdentity::IdentityProvidersL() const + { + return iProviderList; + } + +// NOTE: takes ownership of the given apIdentityProvider +TInt CSenBaseIdentity::RegisterIdentityProviderL(CSenIdentityProvider* apIdentityProvider ) + { + //SENDEBUG_L("CSenBaseIdentity::RegisterIdentityProviderL(*)"); + + if(!apIdentityProvider) + { + SENDEBUG_L("RegisterIdentityProviderL(*) - Illegal argument: NULL"); + return KErrArgument; + } + + if (apIdentityProvider->Endpoint() == KNullDesC8) + { + SENDEBUG_L("RegisterIdentityProviderL(*) - Error: no Endpoint in IDP"); + //Delete the object since ownership is with us + delete apIdentityProvider; + apIdentityProvider = NULL; + return KErrSenNoEndpoint; + } + + TInt retVal(KErrNone); + + // Now check for duplicates: + CSenIdentityProvider* pDuplicate = NULL; + + retVal = FindMatchingIdentityProviderL(*apIdentityProvider, pDuplicate); + if(pDuplicate) + { + //SENDEBUG((_L(" Duplicate(s) found, updating the IdP!."))); + RPointerArray newElements = + apIdentityProvider->AsElement().ElementsL(); + + TInt elemCount = newElements.Count(); + TInt i(0); + // Checking the aIdp elements + while ( i < elemCount ) + { + CSenElement* elem = newElements[i]; + TPtrC8 localName = elem->LocalName(); + + RPointerArray pDuplicateAsElems = + pDuplicate->AsElement().ElementsL(); + TInt duplicateCount = pDuplicateAsElems.Count(); + TBool found = EFalse; + TBool foundServiceID = EFalse; + TInt j(0); + + // Checking if the duplicate has the element found from aIdp + // If found update it, if not found insert new element. + while ( j < duplicateCount ) + { + CSenElement* dupElem = pDuplicateAsElems[j]; + if ( localName == dupElem->LocalName() ) + { + if ( localName == KServiceIDElementLocalName ) + { + if ( elem->Content() == dupElem->Content() ) + { + foundServiceID = ETrue; + } + } + else + { + // note, this create the element if it + // is not found + if (elem->Content() != KNullDesC8) + { + dupElem->SetContentL( elem->Content() ); + } + RPointerArray nestedElems = elem->ElementsL(); + for (TInt k = 0; k < nestedElems.Count(); k++) + { + CSenElement* dupNestEl = dupElem->Element(nestedElems[k]->LocalName()); + if (dupNestEl) + { + dupNestEl->SetContentL(nestedElems[k]->Content()); + } + else + { + CSenElement* newEl = dupElem->CreateElementL(nestedElems[k]->NsPrefix(), + nestedElems[k]->LocalName()); + CleanupStack::PushL(newEl); + dupElem->AddElementL(*newEl); + CleanupStack::Pop(newEl); + newEl->SetContentL(nestedElems[k]->Content()); + } + } + + //cleaning, if sth has been removed on backend + //nested duplicate - local + //nested - backend + RPointerArray nestedDupElems = dupElem->ElementsL(); + for (TInt k = 0; k < nestedDupElems.Count(); k++) + { + CSenElement* nestEl = elem->Element(nestedDupElems[k]->LocalName()); + if (!nestEl) + { + nestedDupElems[k]->SetContentL(KNullDesC8); + } + } + + + found = ETrue; + break; + } + } + j++; + } + + if ( !found && !foundServiceID && elem) + { + // this is new kind of element, and not in original + // idp, thus it needs to be copied because it is + // owned by idp being registered (which will be + // deleted inside this method) + CSenElement* pCopy = + CSenXmlElement::NewL( elem->LocalName() ); + CleanupStack::PushL(pCopy); + // copy the contents of serviceid + pCopy->CopyFromL(*elem); + // append the copy into original idp + pDuplicate->AsElement().AddElementL( *pCopy ); + CleanupStack::Pop(); // pCopy + } + i++; + } + // NOTE: ownership of the given argument apIdentityProvider + // will NOT be TRANSFERRED to anywhere. + // So: free the memory, contents copied and thus updated + + delete apIdentityProvider; + apIdentityProvider = NULL; + if(retVal > 0) + retVal = KErrNone; + } + else if(retVal==KErrNotFound) + { + //SENDEBUG((_L(" No duplicate(s) found, will try to add.."))); + // Append into both provider list and as child element + retVal = iProviderList.Append( apIdentityProvider ); + if(retVal==KErrNone) + { + // OWNERSHIP of apIdentityProvider is now here + TInt leaveCode(KErrNone); + TRAP( leaveCode, AsElement().AddElementL(apIdentityProvider->AsElement() ) ); + if(leaveCode!=KErrNone) + { + retVal = leaveCode; + // no need to free the apIdentityProvider, it will + // be destroyed in destructor as part of iProviderList + } + } + else + { + // free the orphan apIdentityProvider + delete apIdentityProvider; + apIdentityProvider = NULL; + } + } + else // some other error occurred: free the orphan argument + { + //SENDEBUG((_L("An error occured and no duplicate(s) were found."))); + delete apIdentityProvider; + apIdentityProvider = NULL; + } + return retVal; + } + +TInt CSenBaseIdentity::UpdateIdentityProviderL(CSenIdentityProvider& aIdentityProvider) + { + if (aIdentityProvider.Endpoint() == KNullDesC8) + { + SENDEBUG_L("RegisterIdentityProviderL(*) - Error: no Endpoint in IDP"); + return KErrSenNoEndpoint; + } + + TInt retVal(KErrNone); + + // Now check for duplicates: + CSenIdentityProvider* pDuplicate = NULL; + + retVal = FindMatchingIdentityProviderL(aIdentityProvider, pDuplicate); + if(pDuplicate) + { + //SENDEBUG((_L(" Duplicate(s) found, updating the IdP!."))); + RPointerArray newElements = + aIdentityProvider.AsElement().ElementsL(); + + TInt elemCount = newElements.Count(); + TInt i(0); + // Checking the aIdp elements + while ( i < elemCount ) + { + CSenElement* elem = newElements[i]; + TPtrC8 localName = elem->LocalName(); + + RPointerArray pDuplicateAsElems = + pDuplicate->AsElement().ElementsL(); + TInt duplicateCount = pDuplicateAsElems.Count(); + TBool found = EFalse; + TBool foundServiceID = EFalse; + TInt j(0); + + // Checking if the duplicate has the element found from aIdp + // If found update it, if not found insert new element. + while ( j < duplicateCount ) + { + CSenElement* dupElem = pDuplicateAsElems[j]; + if ( localName == dupElem->LocalName() ) + { + if ( localName == KServiceIDElementLocalName ) + { + if ( elem->Content() == dupElem->Content() ) + { + foundServiceID = ETrue; + } + } + else + { + // note, this create the element if it + // is not found + dupElem->SetContentL( elem->Content() ); + found = ETrue; + break; + } + } + j++; + } + + if ( !found && !foundServiceID && elem) + { + // this is new kind of element, and not in original + // idp, thus it needs to be copied because it is + // owned by idp being registered (which will be + // deleted inside this method) + CSenElement* pCopy = + CSenXmlElement::NewL( elem->LocalName() ); + CleanupStack::PushL(pCopy); + // copy the contents of serviceid + pCopy->CopyFromL(*elem); + // append the copy into original idp + pDuplicate->AsElement().AddElementL( *pCopy ); + CleanupStack::Pop(); // pCopy + } + i++; + } + if(retVal > 0) + retVal = KErrNone; + } + + return retVal; + } + +// Note: non-strict search is used when unregistering: it must be possible +// to unregister a provider using only provider Id in cases where someone +// is unable to update and IDP (because provider id was *already *in use). +// This "someone", cannot figure out the endpoint -> so, only way to unregister +// blocking IDP is to call unregister(ProviderID) and then register the IDP +// using different ProviderID & endpoint pair. + +// more about this "non strict" search used by unregistering: to get a MATCH +// usingof plain endpoint must be accepted ONLY if providerid was NOT in use +// with basic web services. +// + +// FOR ID-WSF framework, mainly +TInt CSenBaseIdentity::FindMatchingIdentityProviderL(CSenIdentityProvider& aIdp, + CSenIdentityProvider*& apMatch) + { + //SENDEBUG(( + // _L("CSenBaseIdentity::FindMatchingIdentityProviderL() - Started "))); + + TInt retVal(KErrNotFound); + + TInt idpCount(iProviderList.Count()); + apMatch = NULL; + + for (TInt i=0; iProviderID(); + + TPtrC8 databaseEndpoint = + ((CSenIdentityProvider*)iProviderList[i])->Endpoint(); + + + + TPtrC8 addedProvID = aIdp.ProviderID(); + TPtrC8 addedEndpoint = aIdp.Endpoint(); + + if(databaseProvID==KNullDesC8) + { + // This is Basic Web Services IDP and only endpoint matters + if( databaseEndpoint == addedEndpoint ) + { + retVal = i; // match was found: return the index of found element + apMatch = iProviderList[i]; + } + } + else if(databaseProvID == addedProvID) + { + // This is an ID-WSF IDP, where providerIDs match + + // We might have a match for non-strict ("provider id only" -type search). + // Now we must check that there was + if( databaseEndpoint == addedEndpoint ) + { + apMatch = (CSenIdentityProvider*)iProviderList[i]; + retVal = i; // match was found: return the index of found IDP + } + else + { + // we need to return an error code indicating that provider id + // is already mapped to different endpoint(!) + retVal = KErrSenProviderIdInUseByAnotherEndpoint; + } + } + } + return retVal; + } + + +TInt CSenBaseIdentity::UnregisterIdentityProviderL(CSenIdentityProvider& aIdp ) + { + TInt retVal(KErrNotFound); + + CSenIdentityProvider* pMatch = NULL; + TInt index = FindMatchingIdentityProviderL(aIdp, pMatch); + + if ( index==KErrNotFound || + (aIdp.Endpoint()==KNullDesC8 && + index==KErrSenProviderIdInUseByAnotherEndpoint) + ) + { + // we need to make it possible to unregister an IDP using + // plain provider ID + TPtrC8 providerId = aIdp.ProviderID(); + index = IdentityProviderNamed( providerId, pMatch ); + } + + // index is either >= 0, OR: if nothing was removed, + // return KErrNotFound OR: provider id used by + // another endpoint (new error code) + if(index>=0 && pMatch) + { + // remove the match from database list, which allows us to + // delete the IdP from memory. + iProviderList.Remove(index); + TRAP( retVal, AsElement().RemoveElement(pMatch->AsElement()); ) + delete pMatch; + retVal = KErrNone; + } + + return retVal; // if nothing was removed, this will return KErrNotFound + } + +TBool CSenBaseIdentity::AssociateServiceL(const TDesC8& aServiceID, + const TDesC8& aProviderID) + { + TBool ret = EFalse; + CSenIdentityProvider* prov = IdentityProviderNamed( aProviderID ); + if ( prov != NULL ) + { + if ( !prov->IsTrustedByL( aServiceID )) + { + CSenElement& service = + prov->AsElement().AddElementL(KServiceIDElementLocalName); + + service.SetContentL( aServiceID ); + } + ret = ETrue; + } + return ret; + } + +TBool CSenBaseIdentity::DissociateServiceL(const TDesC8& aServiceID, + const TDesC8& aProviderID) + { + TBool ret = EFalse; + CSenIdentityProvider* prov = IdentityProviderNamed( aProviderID ); + if ( prov != NULL ) + { + if ( prov->IsTrustedByL( aServiceID )) + { + RPointerArray services = + prov->AsElement().ElementsL(); + TInt serviceCount = services.Count(); + TInt i(0); + while (i < serviceCount) + { + if (services[i]->LocalName() == KServiceIDElementLocalName) + { + CSenElement* elem = services[i]; + if ( elem->Content() == aServiceID) + { + TInt retVal; + TRAP(retVal, prov->AsElement().RemoveElement(*elem)); + if (retVal == KErrNone ) + { + if ( elem ) + { + delete elem; + } + ret = ETrue; + } + else + { + ret = EFalse; + } + break; + } + } + i++; + } + } + } + return ret; + } + +void CSenBaseIdentity::StartElementL(const TDesC8& aNsUri, + const TDesC8& aLocalName, + const TDesC8& aQName, + const RAttributeArray& aAttributes) + { + if (aLocalName == KSenIdpLocalname) + { + // create CSenWiseIdentityProvider + iProvider = + CSenWiseIdentityProvider::NewL(iIMEI, KNullDesC8, KNullDesC8); + + iProvider->SetOwner(*this); + iProvider->SetAttributesL(aAttributes); + iProvider->SetReader(*Reader()); + DelegateParsingL(*iProvider); + } + else + { + DelegateParsingL(aNsUri, aLocalName, aQName, aAttributes); + } + } + + +void CSenBaseIdentity::EndElementL(const TDesC8& aNsUri, + const TDesC8& aLocalName, + const TDesC8& aQName) + { + if(aLocalName == KSenIdpLocalname) + { + if(iProvider) + { +#ifdef __CRYPTO_HW__ + TBuf8 decPwd; + TInt leaveCode(KErrNone); + TRAP(leaveCode, DecryptPasswordL(iProvider->Password(), decPwd)); + if (leaveCode == KErrNone) + { + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Identity ::DecryptPasswordL success"))); + } + else + { + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Identity ::DecryptPasswordL Failed"))); + } + iProvider->SetUserInfoL(iProvider->UserName(),iProvider->UserName(), decPwd); + +#endif // __CRYPTO_HW__ + RegisterIdentityProviderL(iProvider); + iProvider=NULL; + } + } + else + { + CSenBaseFragment::EndElementL(aNsUri,aLocalName,aQName); + } + } + +const TDesC8& CSenBaseIdentity::Type() + { + return KNullDesC8; + } + +const TDesC8& CSenBaseIdentity::Name() + { + return KNullDesC8; + } + +const TDesC8& CSenBaseIdentity::UserName() + { + return KNullDesC8; + } + + +HBufC8* CSenBaseIdentity::AsXmlL() + { + return this->AsElement().AsXmlL(); + } + +HBufC* CSenBaseIdentity::AsXmlUnicodeL() + { + return this->AsElement().AsXmlUnicodeL(); + } + +void CSenBaseIdentity::WriteAsXMLToL(RWriteStream& aWriteStream) + { +#ifdef __CRYPTO_HW__ + TInt idpCount(iProviderList.Count()); + + RArray password; + for(TInt i=0; i encPwd; + TInt leaveCode(KErrNone); + //EncryptPasswordL(idp->Password(), encPwd); + TRAP(leaveCode, EncryptPasswordL(idp->Password(), encPwd)); + if (leaveCode == KErrNone) + { + + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Identity ::EncryptPasswordL success"))); + } + else + { + + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Identity ::EncryptPasswordL Failed"))); + } + RBuf8 *tempPass = new RBuf8; + tempPass->Create(idp->Password()); + password.Append(tempPass); + idp->SetUserInfoL(idp->UserName(),idp->UserName(),encPwd); + } +#endif // __CRYPTO_HW__ + this->AsElement().WriteAsXMLToL(aWriteStream); +#ifdef __CRYPTO_HW__ + for(TInt i=0; iSetUserInfoL(idp->UserName(),idp->UserName(),*password[i]); + password[i]->Close(); + delete password[i]; + } +#endif // __CRYPTO_HW__ + } + +EXPORT_C CSenBaseIdentity::~CSenBaseIdentity() + { + if(iProvider) + { + CSenElement* removed = + CSenBaseIdentity::AsElement().RemoveElement(iProvider->AsElement()); + // prevend impossible "duplicate delete" + if(removed) + { + delete iProvider; // a leave occured between + // StartElementL and EndElementL... + } + iProvider = NULL; // to prevent accidental duplicate delete + } + + TInt idpCount(iProviderList.Count()); + for(TInt i=idpCount-1; i>=0; i--) + { + CSenElement* removed = + CSenBaseIdentity::AsElement().RemoveElement( + ((CSenIdentityProvider*)iProviderList[i])->AsElement()); + // prevend impossible "duplicate delete" + if(removed) + { + delete iProviderList[i]; + iProviderList.Remove(i); // 6.11.2004 + } + } + + iProviderList.ResetAndDestroy(); + } + +CSenIdentityProvider* CSenBaseIdentity::IdentityProviderNamed(const TDesC8& aProviderId) + { + CSenIdentityProvider* pMatch = NULL; + IdentityProviderNamed( aProviderId, pMatch ); + return pMatch; + } + +TInt CSenBaseIdentity::IdentityProviderNamed( const TDesC8& aProviderID, + CSenIdentityProvider*& apMatch) + { + TInt idpCount(iProviderList.Count()); + TInt retVal(KErrNotFound); // index, or an error + apMatch = NULL; + for(TInt i=0; iProviderID(); + if(providerId.Length()>0 && providerId == aProviderID) + { + retVal = i; // store the index + apMatch = (CSenIdentityProvider*)iProviderList[i]; // found a match + break; + } + } + return retVal; + } + +TInt CSenBaseIdentity::ContainsIdentityProviderL(TBool& aContains, + CSenIdentityProvider& aIDP) + { + aContains = EFalse; + TInt idpCount(iProviderList.Count()); + + for(TInt i=0; iConsistsOfL(aIDP) + ) + { + aContains = ETrue; + break; // No need to loop the rest of the providers, we are + // happy with the first hit + } + } + return KErrNone; + } +#ifdef __CRYPTO_HW__ +void CSenBaseIdentity::EncryptPasswordL(const TDesC8& aData, TDes8& aCipherText) + { +#ifndef __WINSCW__ + TUint cipherLen; + TBuf8 temp; + + // add padding if length is less than 16 + if (aData.Length() < KCryptoPADataLen) + { + const TInt remainder = aData.Length() % KCryptoPADataLen; + temp.Copy(aData); + temp.AppendFill( KPadding, KCryptoPADataLen - remainder ); + cipherLen = temp.Length() + KPaCryptAuthLen ; + aCipherText.SetLength(cipherLen); + } + else + { + temp.Copy(aData); + cipherLen = aData.Length() + KPaCryptAuthLen ; + aCipherText.SetLength(cipherLen); + } + + TBuf8<20> paId; + paId.Copy(KCryptoPA); + + CSecEnv* secEnv = CSecEnv::NewL(); + TInt err = secEnv->ProtectedApplicationExecute(paId, (TAny*)temp.Ptr(), temp.Length(), + (TAny*)aCipherText.Ptr(), cipherLen, KEncryptNoSalt); + delete secEnv; + + // Encode data into Base64 format + HBufC8 *b64encPwd = SenCryptoUtils::EncodeBase64L(aCipherText); + if(b64encPwd) + { + aCipherText = (*b64encPwd); + delete b64encPwd; + } + + +#else + +aCipherText = aData; +//return KErrNotSupported; +#endif + + } + +void CSenBaseIdentity::DecryptPasswordL(const TDesC8& aCipherText, TDes8& aData) + { +#ifndef __WINSCW__ + TUint dataLen = aCipherText.Length() - KPaCryptAuthLen ; + aData.SetLength(dataLen); + TBuf8<20> paId; + paId.Copy(KCryptoPA); + // Decode data from Base64 format + HBufC8 *b64decPwd = SenCryptoUtils::DecodeBase64L(aCipherText); + TDesC8 aTmpTxt= (*b64decPwd); + // Decrypt using PA + CSecEnv* secEnv = CSecEnv::NewL(); + TInt err = secEnv->ProtectedApplicationExecute(paId, (TAny*)aTmpTxt.Ptr(), aTmpTxt.Length(), + (TAny*)aData.Ptr(), dataLen, KDecrypt); + // remove padding + if (aData.Length() == KCryptoPADataLen) + { + RBuf8 decPwd; + decPwd.Create(KCryptoPADataLen); + decPwd.Copy(aData); + TInt pos = decPwd.Locate(KPadding); + if(pos != KErrNotFound) + { + decPwd.SetLength(pos); + aData.SetLength(decPwd.Length()); + aData = decPwd; + } + decPwd.Close(); + } + delete secEnv; + if(b64decPwd) + { + delete b64decPwd; + } +#else + +aData = aCipherText ; +//return KErrNotSupported; +#endif +} +#endif // __CRYPTO_HW__