1 /*

     2 * Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:          

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 #include "sencredentialmanager.h"

    26 #include "seninternalcredential.h"

    27 

    28 #include <s32mem.h>

    29 #include <s32file.h>

    30 #include <sysutil.h>

    31 #include <SenXmlProperties.h>

    32 #include <SenXmlConstants.h>

    33 

    34 #include "sendebug.h"               // internal \Utils\inc - filelogging MACROs

    35 #include "senlogger.h"

    36 #include "msencoreservicemanager.h" // internal \Framework\inc

    37 

    38 #include "senservicemanagerdefines.h" // KMaxTicks (1209600000)

    39                                       // 1 tick = 1 millisec

    40                                       // 86400 sec = 1 day

    41                                       // 86400*1000 millisec = 1 day

    42                                       // 86400*14*1000 = 1209600000 millisec = 2 weeks

    43 

    44 #include "SenParser.h"

    45 #include "SenDateUtils.h"

    46 #include "senwsdescription.h"

    47 #include "senwebservicesession.h"

    48 

    49 #include <SenServiceConnection.h> // KErrSenNoPermission ( -30315 )

    50 #include <xmlengnodelist.h> 

    51 #include <SenCredential.h>

    52 

    53 #include <SenXmlUtils.h>

    54 #ifdef __CRYPTO_HW__

    55 #include "sencryptoutils.h"

    56 #include <SecEnv.h>

    57 #include <SecEnvDevice.h>

    58 #include <SecEnvType.h>

    59 #include <SecEnvMgr.h>

    60 const TInt KCryptoPADataLen     = 16;

    61 const TInt KCryptoPACipherLen   = 48;

    62 const TInt KPaCryptAuthLen     = 32;

    63 const TInt KEncryptNoSalt = 3;

    64 const TInt KDecrypt       = 2;

    65 const TUint KPadding = 0;

    66 const TUint KEncrypedLen = 128;

    67 _LIT8(KCryptoPA, "PA_CRYPT");

    68 #endif // __CRYPTO_HW__

    69 

    70 namespace

    71     {

    72 #if !defined( EKA2 ) && !defined( RD_SECURE_PRIV_DATA )

    73     _LIT(KCredentialFile,           "C:\\system\\data\\sencredentials.xml");

    74 #else

    75     _LIT(KCredentialFile,           "sencredentials.xml");

    76 #endif

    77 

    78     _LIT8(KCredentials,             "Credentials");

    79     _LIT8(KCredentialsMaxID,        "CredentialsMaxID");

    80     _LIT8(KCredentialContainer,     "CredentialContainer");

    81     _LIT8(KCredentialIdentifier,    "Identifier");

    82     _LIT8(KCredentialProperties,    "Properties");

    83     _LIT8(KTouch,    "touch");

    84     _LIT8(KCredentialId, "CredentialId");

    85     

    86     const TInt KStateParsingCredentialContainer   = 99;

    87     const TInt KStateParsingCredentialIdentifier  = 100;

    88     const TInt KStateParsingCredentialProperties  = 102;

    89     const TInt KStateParsingCredential            = 104;

    90     const TInt KFlatBufSize                       = 128;

    91     

    92     /* microseconds before actual notOnOrAfter (or validUntil) time

    93      * when credentials are treated as expired.

    94      */

    95     const TInt KClockSlipMicroSeconds = 3*60*1000*1000;

    96     }

    97 

    98 EXPORT_C CSenCredentialManager* CSenCredentialManager::NewL(MSenCoreServiceManager& aManager)

    99     {

   100     CSenCredentialManager* pNew = NewLC(aManager);

   101     CleanupStack::Pop(pNew);

   102     return(pNew);

   103     }

   104 

   105 EXPORT_C CSenCredentialManager* CSenCredentialManager::NewLC(MSenCoreServiceManager& aManager)

   106     {

   107     CSenCredentialManager* pNew = new (ELeave) CSenCredentialManager(aManager);

   108     CleanupStack::PushL(pNew);

   109     pNew->ConstructL();

   110     return pNew;

   111     }

   112 

   113 CSenCredentialManager::CSenCredentialManager(MSenCoreServiceManager& aManager)

   114 : iManager(aManager),

   115   iLog((RFileLogger*)aManager.Log()),

   116   iMaxCredentialID(0)

   117     {

   118     }

   119 

   120 EXPORT_C CSenCredentialManager::~CSenCredentialManager()

   121     {

   122     SaveCredentialDB();

   123     

   124     TInt count = iCredentialArray.Count();

   125     for (TInt i=0; i < count; i++)

   126         {

   127         iCredentialArray[i].Close();

   128         }

   129     iCredentialArray.Close();

   130     

   131     delete ipParser;

   132     

   133     // Sanity check for Delegates (which are not handled correctly

   134     //                             during parsing)

   135     delete ipCredentialContainer;

   136     delete ipCredentialIdentifier;

   137     delete ipCredentialProperties;

   138     delete ipCredential;

   139     }

   140 

   141 void CSenCredentialManager::ConstructL()

   142     {

   143     TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenCredentialManager::ConstructL");

   144     BaseConstructL(KCredentials);

   145     LoadDB();

   146     }

   147 

   148 RFileLogger* CSenCredentialManager::Log()

   149     {

   150     return iLog;

   151     }

   152     

   153 void CSenCredentialManager::OnStartElementL(const RTagInfo& aElement,

   154                                             const RAttributeArray& aAttributes,

   155                                             TInt aErrorCode)

   156     {

   157     const TPtrC8 localName   = aElement.LocalName().DesC();

   158     

   159     switch (iState)

   160         {

   161         case KSenStateSave:

   162             {

   163             const TPtrC8 saxLocalName   = aElement.LocalName().DesC();

   164             

   165             if (saxLocalName == KCredentialContainer)

   166                 {

   167                 if ( ipCredentialContainer )

   168                     {

   169                     TXmlEngElement element  = ipCredentialContainer->AsElementL();

   170                     element.Remove(); // Deletes Container from Dom tree

   171                     delete ipCredentialContainer;

   172                     ipCredentialContainer = NULL;

   173                     }

   174                     

   175                 const TPtrC8 saxNsUri       = aElement.Uri().DesC();

   176                 const TPtrC8 saxPrefix      = aElement.Prefix().DesC();

   177 

   178                 TXmlEngElement element = AsElementL();

   179                 RSenDocument   document = AsDocumentL();

   180 

   181 				ipCredentialContainer = CSenFragmentBase::NewL(

   182 					                         saxNsUri, saxLocalName,

   183 					                         saxPrefix, aAttributes,

   184 					                         element, document 

   185 					                         );

   186 					                         

   187                 iState = KStateParsingCredentialContainer;

   188                 }

   189 

   190             break;

   191             }

   192         case KStateParsingCredentialContainer: // KStateParsingCredentialContainer 

   193                                                // is also Save state

   194             {

   195             const TPtrC8 saxLocalName   = aElement.LocalName().DesC();

   196 

   197             if (saxLocalName == KCredentialIdentifier)

   198                 {

   199                 if ( ipCredentialIdentifier )

   200                     {

   201                     TXmlEngElement element  = ipCredentialIdentifier->AsElementL();

   202                     element.Remove(); // Deletes Identifier from Dom tree

   203                     delete ipCredentialIdentifier;

   204                     ipCredentialIdentifier = NULL;

   205                     }

   206                 

   207                 const TPtrC8 saxNsUri       = aElement.Uri().DesC();

   208                 const TPtrC8 saxPrefix      = aElement.Prefix().DesC();

   209 

   210                 TXmlEngElement element  = ipCredentialContainer->AsElementL();

   211                 RSenDocument   document = AsDocumentL();

   212 

   213 				ipCredentialIdentifier = CSenCredentialIdentifier::NewL(

   214 					                         saxNsUri, saxLocalName,

   215 					                         saxPrefix, aAttributes,

   216 					                         element, document 

   217 					                         );

   218 

   219                 iState = KStateParsingCredentialIdentifier;

   220 

   221                 OnDelegateParsingL(*ipCredentialIdentifier);

   222                 }

   223             else if (saxLocalName == KCredentialProperties)

   224                 {

   225                 if ( ipCredentialProperties )

   226                     {

   227                     TXmlEngElement element  = ipCredentialProperties->AsElementL();

   228                     element.Remove(); // Deletes Properties from Dom tree

   229                     delete ipCredentialProperties;

   230                     ipCredentialProperties = NULL;

   231                     }

   232                 

   233                 const TPtrC8 saxNsUri       = aElement.Uri().DesC();

   234                 const TPtrC8 saxPrefix      = aElement.Prefix().DesC();

   235 

   236                 TXmlEngElement element  = ipCredentialContainer->AsElementL();

   237                 RSenDocument   document = AsDocumentL();

   238 

   239 				ipCredentialProperties = CSenCredentialProperties::NewL(

   240 					                         saxNsUri, saxLocalName,

   241 					                         saxPrefix, aAttributes,

   242 					                         element, document 

   243 					                         );

   244 

   245                 iState = KStateParsingCredentialProperties;

   246 

   247                 OnDelegateParsingL(*ipCredentialProperties);

   248                 }

   249             else 

   250                 {

   251                 // Parsing Credential

   252                 // 

   253                 // <=> Container can have only three elements:

   254                 //     1) CredentialIdentifier,

   255                 //     2) CredentialProperties and

   256                 //     3) Credential (which LocalName we do not know)

   257                 //

   258                 //     If we see that LocalName was not CredentialIdentifier

   259                 //                                      or CredentialProperties

   260                 //     we know that we are handling Credential.

   261                 

   262                 if ( ipCredential )

   263                     {

   264                     TXmlEngElement element  = ipCredential->AsElementL();

   265                     element.Remove(); // Deletes Credential from Dom tree

   266                     delete ipCredential;

   267                     ipCredential = NULL;

   268                     }

   269                 

   270                 const TPtrC8 saxNsUri       = aElement.Uri().DesC();

   271                 const TPtrC8 saxPrefix      = aElement.Prefix().DesC();

   272 

   273                 TXmlEngElement element  = ipCredentialContainer->AsElementL();

   274                 RSenDocument   document = AsDocumentL();

   275 

   276 				ipCredential = CSenInternalCredential::NewL(

   277 					                         saxNsUri, saxLocalName,

   278 					                         saxPrefix, aAttributes,

   279 					                         element, document 

   280 					                         );

   281 		        ipCredential->SetIdentifier(ipCredentialIdentifier);

   282 		        ipCredentialIdentifier = NULL;

   283 

   284 		        ipCredential->SetProperties(ipCredentialProperties);

   285 		        ipCredentialProperties = NULL;

   286 

   287                 iState = KStateParsingCredential;

   288 

   289                 OnDelegateParsingL(*ipCredential);

   290                 }

   291             break;

   292             }

   293         default:

   294             {

   295             const TPtrC8 saxLocalName   = aElement.LocalName().DesC();

   296 

   297             if (saxLocalName == KCredentials)

   298                 {

   299                 TInt count(aAttributes.Count());

   300 

   301                 for (TInt i=0; i<count; i++)

   302                     {

   303                     TPtrC8 localName = aAttributes[i].Attribute().LocalName().DesC();

   304                     TPtrC8 value = aAttributes[i].Value().DesC();

   305                     

   306                     if ( localName == KCredentialsMaxID )

   307                         {

   308                         TLex8 lex;

   309                         lex.Assign(value);

   310                         lex.Val( iMaxCredentialID );                        

   311                         break;

   312                         }

   313                     }

   314                 }

   315                 

   316             CSenFragmentBase::OnStartElementL( aElement, aAttributes, aErrorCode );

   317             break;

   318             }

   319         }

   320     }

   321     

   322 void CSenCredentialManager::OnEndElementL( const RTagInfo& aElement, TInt aErrorCode )

   323 

   324     {

   325     const TPtrC8 localName   = aElement.LocalName().DesC();

   326 

   327     switch(iState)

   328         {

   329         case KStateParsingCredentialIdentifier:

   330             {

   331 #ifdef __CRYPTO_HW__

   332 

   333             TInt leaveCode(KErrNone);  

   334  			TPtrC8 pass;

   335             TBuf8<KEncrypedLen> decPwd;

   336             ipCredentialIdentifier->PropertyL(KSenIdpPasswordLocalname, pass);

   337             TRAP(leaveCode, DecryptPasswordL(pass, decPwd));

   338             if (leaveCode == KErrNone)

   339                 {

   340                 TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("SenCredentialManager::DecryptPasswordL success")));

   341                 }

   342             else

   343                 {

   344                 TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("SenCredentialManager::DecryptPasswordL Failed"))); 

   345                 }

   346 			ipCredentialIdentifier->SetPropertyL(KSenIdpPasswordLocalname, decPwd);       			

   347 			

   348 #endif // __CRYPTO_HW__			

   349             iState = KStateParsingCredentialContainer;

   350             break;

   351             }

   352         case KStateParsingCredentialProperties:

   353             {

   354             iState = KStateParsingCredentialContainer;

   355             break;

   356             }

   357         case KStateParsingCredential:

   358             {

   359             TTime now;

   360             now.UniversalTime();

   361             

   362             TPtrC8 value;

   363             TTimeIntervalMicroSeconds clientServerInterval = 0;

   364             TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"Checking 'ServiceInterval' property.");

   365             _LIT8(KServiceInterval,"ServiceInterval");	//CodeScannerWarnings

   366             TInt ret = ipCredential->PropertiesL().PropertyL(KServiceInterval, value);

   367             

   368             TBool propertiesExist(ETrue);

   369             

   370             if ( ret == KErrNone )

   371                 {

   372                 TLex8 lex(value);

   373                 TInt64 val;

   374                 ret = lex.Val(val);

   375                 TTimeIntervalMicroSeconds clientServerInterval = val;

   376                 if ( ret == KErrNone )

   377                     {

   378 #ifdef _SENDEBUG

   379                     TInt leaveCode(KErrNone);

   380                     TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts;

   381                     TRAP(leaveCode, SenDateUtils::ToXmlDateTimeUtf82L(ts, now);)

   382                     if (leaveCode == KErrNone)

   383                         {

   384                         TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("Client time : %S"), &ts));

   385                         }

   386 #endif // _SENDEBUG

   387                     now += clientServerInterval;

   388 #ifdef _SENDEBUG

   389                     TBuf8<64> buf;

   390                     buf.AppendNum(clientServerInterval.Int64());

   391                     TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("Client-Server Interval in microseconds: %S"),&buf));

   392                     TRAP(leaveCode, SenDateUtils::ToXmlDateTimeUtf82L(ts, now);)

   393                     if (leaveCode == KErrNone)

   394                         {

   395                         TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("Fixed client time : %S"), &ts));

   396                         }

   397                     leaveCode = 0; // not used

   398 #endif // _SENDEBUG

   399                     }

   400                 }

   401             else if ( ret == KErrNotFound )

   402                 {

   403                 TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- 'ServiceInterval' not found.");

   404                 TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"Checking 'ValidUntil' property.");

   405                 TInt ret2 = ipCredential->PropertiesL().PropertyL(_L8("ValidUntil"), value);

   406                 if ( ret2 == KErrNotFound )

   407                     {

   408                     TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- 'ValidUntil' not found.");

   409                     propertiesExist = EFalse;

   410                     }

   411                 }                

   412             

   413             if ( !propertiesExist ||

   414                 ( ( ipCredential->PropertiesL().ValidUntilL() != Time::NullTTime() ) &&

   415                  ( now > (ipCredential->PropertiesL().ValidUntilL()-TTimeIntervalMicroSeconds(KClockSlipMicroSeconds)) ) )

   416                )

   417                 {

   418                 

   419 #ifdef _SENDEBUG

   420                 if ( propertiesExist )

   421                     {

   422                     TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("- Loaded credential is expired:")));

   423                     TInt leaveCode(KErrNone);

   424                     TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts2;

   425                     TRAP(leaveCode, SenDateUtils::ToXmlDateTimeUtf82L(ts2, ipCredential->PropertiesL().ValidUntilL());)//codescannerwarnings

   426                     TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("- Credential time : %S, clockslip: %d micros"), &ts2, KClockSlipMicroSeconds));

   427                     leaveCode = 0; // not used

   428                     }

   429                 else

   430                     {

   431                     TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- Neither 'ValidUntil' or 'ServiceInterval' exist: credential should be discarded(!)");

   432                     }

   433 #endif // _SENDEBUG

   434                 TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("-- Invalid credential will be removed from CredentialManager.")));

   435 

   436                 

   437                 delete ipCredential;            

   438                 ipCredential = NULL;         

   439                 }

   440             else

   441                 {

   442                 if ( ipCredential->PropertiesL().ValidUntilL() != Time::NullTTime() )

   443                     {

   444                     TTime validUntil = ipCredential->PropertiesL().ValidUntilL();

   445                     ipCredential->SetValidUntil(validUntil);

   446                     }

   447                 

   448                 RSenCredentialPtr credentialPtr;

   449                 credentialPtr.OpenL(ipCredential);

   450                 CleanupClosePushL(credentialPtr);

   451                 iCredentialArray.Append(credentialPtr);

   452                 CleanupStack::Pop(&credentialPtr);

   453                 }

   454                 

   455             ipCredential = NULL;

   456 

   457             iState = KStateParsingCredentialContainer;

   458             break;

   459             }

   460         case KStateParsingCredentialContainer:

   461             {

   462             if(localName == KCredentialContainer)

   463             	{

   464             if ( ipCredentialContainer )

   465                 {

   466                 TXmlEngElement element  = ipCredentialContainer->AsElementL();

   467                 RXmlEngNodeList<TXmlEngElement> children;

   468                 

   469                 CleanupClosePushL(children);

   470                 element.GetChildElements(children);

   471     

   472                 // Element should always have 3 child elements:

   473                 //         1) CredentialIdentifier and

   474                 //         2) Credential

   475                 //         3) CredentialProperties

   476                 if ( children.Count() < 2 )

   477                     {

   478                     if ( ipCredentialIdentifier )

   479                         {

   480                         TXmlEngElement element  = ipCredentialIdentifier->AsElementL();

   481                         element.Remove(); // Deletes Identifier from Dom tree

   482                         delete ipCredentialIdentifier;

   483                         ipCredentialIdentifier = NULL;

   484                         }

   485                     if ( ipCredentialProperties )

   486                         {

   487                         TXmlEngElement element  = ipCredentialProperties->AsElementL();

   488                         element.Remove(); // Deletes Identifier from Dom tree

   489                         delete ipCredentialProperties;

   490                         ipCredentialProperties = NULL;

   491                         }

   492                     if ( ipCredential )

   493                         {

   494                         TXmlEngElement element  = ipCredential->AsElementL();

   495                         element.Remove(); // Deletes Credential from Dom tree

   496                         delete ipCredential;

   497                         ipCredential = NULL;

   498                         }

   499                     element.Remove();

   500                     }

   501                 CleanupStack::PopAndDestroy(&children);

   502 

   503                 delete ipCredentialContainer;

   504                 ipCredentialContainer = NULL;

   505                 if ( ipContentBuf )

   506     				{

   507 	                

   508     		    	delete ipContentBuf;

   509         			ipContentBuf = NULL;

   510         

   511         			delete ipContentWriteStream;

   512         			ipContentWriteStream = NULL;

   513         			}

   514                 }

   515                 

   516             iState = KSenStateSave;

   517             break;

   518             	}

   519             	else

   520             	{

   521             		return;

   522             	}

   523             }

   524         default:

   525             {

   526             CSenFragmentBase::OnEndElementL(aElement, aErrorCode);

   527             

   528             break;

   529             }

   530         }

   531     }    

   532     

   533 TInt CSenCredentialManager::LoadDB()

   534     {

   535     TInt retVal(KErrNone);

   536 	if ( !ipParser )

   537         {

   538         TRAP( retVal, ipParser = CSenParser::NewL(); )

   539         if( retVal == KErrNone )

   540             {

   541             ipParser->EnableFeature(EReportNamespaceMapping);

   542             }

   543         }

   544     if( retVal == KErrNone )

   545         {

   546         TRAP(retVal, LoadFromL(KCredentialFile));

   547         }

   548     return retVal;

   549     }

   550 

   551 void CSenCredentialManager::LoadFromL(const TDesC& aFile)

   552     {

   553     RFs fss;

   554     User::LeaveIfError(fss.Connect());

   555     CleanupClosePushL(fss);

   556 

   557     TInt leaveCode(KErrNone);

   558 

   559 #if defined( EKA2 ) || defined( RD_SECURE_PRIV_DATA )

   560     TBuf<KMaxPath> file;

   561     fss.CreatePrivatePath(EDriveC);

   562     fss.PrivatePath(file);

   563     file.Append(aFile);

   564     TRAP(leaveCode, ipParser->ParseL(fss, file, *this));

   565 #else

   566     TRAP(leaveCode, aReader.ParseL(fss, aFile, *this));

   567 #endif

   568 

   569     iState = KSenStateSave;

   570     

   571 #ifdef _SENDEBUG

   572     if(leaveCode == KErrNotFound)

   573         {

   574         TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- The sencredentials.xml does not exist!");

   575         TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- New file will be generated.");

   576         }

   577     else if(leaveCode != KErrNone)

   578         {

   579         TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("- Parsing of sencredentials.xml leaved: %d"), leaveCode));

   580         }

   581     else

   582         {

   583         TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- Credential database (sencredentials.xml) successfully read.");

   584         }

   585 #else

   586     leaveCode=0; // this is a decision: we are not interested

   587                  // of invalid input in read/parse phase

   588 #endif

   589 

   590     SaveCredentialDB(); // Always validate by saving

   591 

   592     CleanupStack::PopAndDestroy(); // fss

   593     }

   594 

   595 TInt CSenCredentialManager::SaveCredentialDB()

   596     {

   597     TInt retVal(KErrNone);

   598     TRAP(retVal, SaveToL(KCredentialFile));

   599     return retVal;

   600     }

   601 

   602 TInt CSenCredentialManager::SaveToL(const TDesC& aFile)

   603     {

   604     TInt count = iCredentialArray.Count();

   605     TInt maxId = 0;

   606 #ifdef __CRYPTO_HW__

   607 

   608 	RArray<RBuf8 *> password;

   609 	TPtrC8 tempPass;

   610 	TInt leaveCode(KErrNone);

   611 

   612 #endif // __CRYPTO_HW__

   613     for (TInt i=0; i<count; i++)

   614         {

   615 #ifdef __CRYPTO_HW__		

   616         iCredentialArray[i].Credential()->IdentifierL().PropertyL(KSenIdpPasswordLocalname, tempPass);

   617         RBuf8 *pTempBuf = new RBuf8;

   618         pTempBuf->Create(tempPass);

   619         password.Append(pTempBuf);

   620                 

   621         leaveCode = KErrNone;

   622         TBuf8<KEncrypedLen> encPwd;

   623         TRAP(leaveCode, EncryptPasswordL(tempPass, encPwd));

   624         if (leaveCode == KErrNone)

   625             {

   626             TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("SenCredentialManager::EncryptPasswordL success")));

   627             }

   628         else

   629             {

   630             TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("SenCredentialManager::EncryptPasswordL Failed")));

   631             }

   632        // EncryptPasswordL(tempPass, encPwd);

   633         iCredentialArray[i].Credential()->IdentifierL().SetPropertyL(KSenIdpPasswordLocalname, encPwd);

   634 #endif // __CRYPTO_HW__		

   635         if ( iCredentialArray[i].Credential()->IdentifierL().IdL() > maxId )

   636             {

   637             maxId = iCredentialArray[i].Credential()->IdentifierL().IdL();

   638             }

   639         }

   640     iMaxCredentialID = maxId;

   641     UpdateMaxCredentialIdL();

   642 

   643     // First, collect everything into MEMORY

   644     CBufFlat *pBuf = CBufFlat::NewL(KFlatBufSize);

   645     CleanupStack::PushL(pBuf);

   646 

   647     RBufWriteStream bufWs(*pBuf);

   648     CleanupClosePushL(bufWs);

   649 

   650     WriteAsXMLToL(bufWs);

   651 

   652     TPtrC8 p8 = pBuf->Ptr(0);

   653 

   654     CleanupStack::PopAndDestroy(1); // bufWs

   655 

   656     // Everything in MEMORY ok, prepare to write into file

   657     RFs fss;

   658     User::LeaveIfError(fss.Connect());

   659     CleanupClosePushL(fss);

   660 

   661     RFileWriteStream fileOutStream;

   662     CleanupClosePushL(fileOutStream);

   663 

   664     if(!SysUtil::FFSSpaceBelowCriticalLevelL(&fss, p8.Length()) )

   665         {

   666         //Data caging 2 implementation

   667 #if defined( EKA2 ) || defined( RD_SECURE_PRIV_DATA )

   668         TBuf<KMaxPath> file;

   669         fss.CreatePrivatePath(EDriveC);

   670         fss.PrivatePath(file);

   671         file.Append(aFile);

   672         fileOutStream.Replace(fss, file, EFileWrite);

   673 #else

   674         fileOutStream.Replace(fss, aFile, EFileWrite);

   675 #endif

   676         // finally write the UTF-8 into the file. 

   677         fileOutStream.WriteL(p8);

   678         }

   679 

   680     CleanupStack::PopAndDestroy(3); // fileOutStream, fss, pBuf

   681 #ifdef __CRYPTO_HW__

   682     for (TInt i=0; i<count; i++)

   683         {

   684         iCredentialArray[i].Credential()->IdentifierL().SetPropertyL(KSenIdpPasswordLocalname, *password[i]);

   685         password[i]->Close();

   686         delete password[i];

   687         }

   688 #endif // __CRYPTO_HW__	

   689     return KErrNone;

   690     }

   691     

   692 TInt CSenCredentialManager::CredentialsL(const CSenWSDescription& aPattern,

   693 								         RSenCredentialArray& aCredentials)

   694     {

   695     TInt retVal(KErrNotFound);

   696  //   RefreshMTL(aPattern);

   697     

   698     TInt count = iCredentialArray.Count();

   699     

   700     for (TInt i=0; i<count; i++)

   701         {

   702         if(IsApplicableOrShareableL(aPattern, iCredentialArray[i].Credential()))

   703 //        if ( iCredentialArray[i].Credential()->IsApplicable(aPattern) )

   704             {

   705             TPtrC8 providerId;

   706             retVal = iCredentialArray[i].Credential()->IdentityProviderIdL(providerId);

   707             if ( retVal == KErrNone )

   708                 {

   709                 CSenWSDescription* pPattern = CSenWSDescription::NewLC();

   710                 pPattern->SetEndPointL(providerId);

   711                 CSenIdentityProvider* pProvider = iManager.IdentityProviderL(*pPattern);

   712                 CleanupStack::PopAndDestroy(pPattern);

   713                 if ( pProvider )

   714                     {

   715                     if ( ( pProvider->UserName() == KNullDesC8 ) &&

   716                          ( pProvider->Password() == KNullDesC8 ) )

   717                         {

   718                         aCredentials.AppendL(iCredentialArray[i].Credential());

   719                         }

   720                     else

   721                         {

   722                         retVal = KErrSenNoPermission;

   723                         }

   724                     }

   725                 else

   726                     {

   727                     // Note: Serene DB should not contain Credential

   728                     //       which has IdentityProviderId which points

   729                     //       to non-existent IdentityProvider.

   730                     // After all we cannot give access to Credential

   731                     // which has IdentityProviderId, even though actual

   732                     // IdentityProvider can not be found anymore.

   733                     retVal = KErrSenNoPermission;

   734                     }

   735                 }

   736             else

   737                 {

   738                 aCredentials.AppendL(iCredentialArray[i].Credential());                

   739                 }

   740             }

   741         }

   742 

   743     if ( aCredentials.Count() == 0 )

   744         {

   745         return retVal;

   746         }

   747         

   748     return KErrNone;

   749     }

   750 

   751 TBool CSenCredentialManager::IsAuto(CSenIdentityProvider& aIdp)

   752     {

   753     CSenElement* el(NULL);

   754     TPtrC8 ext = aIdp.AccountExtensions(el);

   755     if (ext == KNullDesC8)

   756         {

   757         if (el)

   758             {

   759             el = el->Element(KSenAccAutoSignIn);

   760             if (el && el->Content() == KSenPropertyTrue)

   761                 {

   762                 return ETrue;

   763                 }

   764             }

   765         }

   766     else

   767         {

   768         RBuf8 mask;

   769         mask.Create(KSenAccAutoSignIn().Length() +

   770                     KSenGreaterThan().Length() +

   771                     KSenPropertyTrue().Length());

   772         mask.CleanupClosePushL();

   773         mask.Append(KSenAccAutoSignIn);

   774         mask.Append(KSenGreaterThan);

   775         mask.Append(KSenPropertyTrue);

   776         if (ext.FindF(mask) != KErrNotFound)

   777             {                                    

   778             return ETrue;

   779             }

   780         CleanupStack::PopAndDestroy(&mask);

   781         }          

   782     return EFalse;

   783     }

   784 TInt CSenCredentialManager::CredentialsL(const CSenWSDescription& aPattern,

   785 								         const CSenIdentityProvider& aIdP,

   786 								         RSenCredentialArray& aCredentials)

   787     {

   788  //   RefreshMTL(aPattern);

   789     TInt count = iCredentialArray.Count();

   790     for (TInt i=0; i<count; i++)

   791         {

   792         if(IsApplicableOrShareableL(aPattern, iCredentialArray[i].Credential()))

   793 //        if ( iCredentialArray[i].Credential()->IsApplicable(aPattern) )

   794             {

   795             TPtrC8 providerId;

   796             TInt retVal = iCredentialArray[i].Credential()->IdentityProviderIdL(providerId);

   797             

   798             if ( retVal == KErrNone )

   799                 {

   800                 CSenWSDescription* pPattern = CSenWSDescription::NewLC();

   801                 pPattern->SetEndPointL(providerId);

   802                 CSenIdentityProvider* pProvider = iManager.IdentityProviderL(*pPattern);

   803                 CleanupStack::PopAndDestroy(pPattern);

   804                 CSenCredentialIdentifier& identifier = iCredentialArray[i].Credential()->IdentifierL();

   805                 

   806                 TPtrC8 usernameIdent;

   807                 TInt retVal = identifier.PropertyL(KSenIdpAuthzIDLocalname, usernameIdent);

   808                 TPtrC8 passwordIdent;

   809                 retVal = identifier.PropertyL(KSenIdpPasswordLocalname, passwordIdent);

   810                 

   811                 TPtrC8 usernameProv  =  ((CSenIdentityProvider&)aIdP).UserName();

   812                 TPtrC8 passwordProv  = ((CSenIdentityProvider&)aIdP).Password();

   813 

   814                 HBufC8* decPasswordIden = SenXmlUtils::DecodeHttpCharactersLC(passwordIdent);

   815                 HBufC8* decPasswordProv = SenXmlUtils::DecodeHttpCharactersLC(passwordProv);          

   816                 

   817                 if( ( usernameIdent.Length() == 0 || usernameIdent == usernameProv ) &&

   818                         (

   819                         ( decPasswordIden->Length() == 0 || *decPasswordIden == *decPasswordProv ) 

   820                         ||

   821                         (IsAuto(*pProvider) && *decPasswordProv == KNullDesC8)

   822                         )

   823                     )

   824                     {

   825                     aCredentials.AppendL(iCredentialArray[i].Credential());

   826                     }

   827                 CleanupStack::PopAndDestroy(2); // decode x2

   828                 }

   829             }

   830         }

   831         

   832     if ( aCredentials.Count() == 0 )

   833         {

   834         return KErrNotFound;

   835         }

   836         

   837     return KErrNone;

   838     }

   839 

   840 TInt CSenCredentialManager::CredentialsL(const CSenWSDescription& aPattern,

   841 								         RSenCredentialPtrArray& aCredentials)

   842     {

   843     TInt retVal(KErrNotFound);

   844     

   845     TInt count = iCredentialArray.Count();

   846     

   847     for (TInt i=0; i<count; i++)

   848         {

   849         if(IsApplicableOrShareableL(aPattern, iCredentialArray[i].Credential()))

   850 //        if ( iCredentialArray[i].Credential()->IsApplicable(aPattern) )

   851             {

   852             TPtrC8 providerId;

   853             retVal = iCredentialArray[i].Credential()->IdentityProviderIdL(providerId);

   854             if ( retVal == KErrNone )

   855                 {

   856                 CSenWSDescription* pPattern = CSenWSDescription::NewLC();

   857                 pPattern->SetEndPointL(providerId);

   858                 CSenIdentityProvider* pProvider = iManager.IdentityProviderL(*pPattern);

   859                 CleanupStack::PopAndDestroy(pPattern);

   860                 if ( pProvider )

   861                     {

   862                     if ( ( pProvider->UserName() == KNullDesC8 ) &&

   863                          ( pProvider->Password() == KNullDesC8 ) )

   864                         {

   865                         aCredentials.AppendL(iCredentialArray[i]);

   866                         }

   867                     else

   868                         {

   869                         retVal = KErrSenNoPermission;

   870                         }

   871                     }

   872                 else

   873                     {

   874                     // Note: Serene DB should not contain Credential

   875                     //       which has IdentityProviderId which points

   876                     //       to non-existent IdentityProvider.

   877                     // After all we cannot give access to Credential

   878                     // which has IdentityProviderId, even though actual

   879                     // IdentityProvider can not be found anymore.

   880                     retVal = KErrSenNoPermission;

   881                     }

   882                 }

   883             else

   884                 {

   885                 aCredentials.AppendL(iCredentialArray[i]);                

   886                 }

   887             }

   888         }

   889 

   890     if ( aCredentials.Count() == 0 )

   891         {

   892         return retVal;

   893         }

   894         

   895     return KErrNone;

   896     }

   897 

   898 TInt CSenCredentialManager::CredentialsL(const CSenWSDescription& aPattern,

   899 								         const CSenIdentityProvider& aIdP,

   900 								         RSenCredentialPtrArray& aCredentials)

   901     {

   902     TInt count = iCredentialArray.Count();

   903     for (TInt i=0; i<count; i++)

   904         {

   905         if(IsApplicableOrShareableL(aPattern, iCredentialArray[i].Credential()))

   906 //        if ( iCredentialArray[i].Credential()->IsApplicable(aPattern) )

   907             {

   908             TPtrC8 providerId;

   909             TInt retVal = iCredentialArray[i].Credential()->IdentityProviderIdL(providerId);

   910             if ( retVal == KErrNone )

   911                 {

   912                 /*CSenWSDescription* pPattern = CSenWSDescription::NewLC();

   913                 pPattern->SetEndPointL(providerId);

   914                 CSenIdentityProvider* pProvider = iManager.IdentityProviderL(*pPattern);

   915                 CleanupStack::PopAndDestroy(pPattern);

   916                 if ( pProvider )

   917                     {

   918                     if ( ( ((CSenIdentityProvider&)aIdP).UserName() == pProvider->UserName() ) &&

   919                          ( ((CSenIdentityProvider&)aIdP).Password() == pProvider->Password() ) )

   920                         {

   921                         aCredentials.AppendL(iCredentialArray[i]);

   922                         }

   923                     }*/

   924                 CSenCredentialIdentifier& identifier = iCredentialArray[i].Credential()->IdentifierL();

   925 

   926                 TPtrC8 username;

   927                 TInt retVal = identifier.PropertyL(KSenIdpAuthzIDLocalname, username);

   928                 TPtrC8 passwordId;

   929                 retVal = identifier.PropertyL(KSenIdpPasswordLocalname, passwordId);

   930                 HBufC8* decPasswordId = SenXmlUtils::DecodeHttpCharactersLC(passwordId);

   931                 

   932                 TPtrC8 passwordProv  = ((CSenIdentityProvider&)aIdP).Password();

   933                 HBufC8* decPasswordProv = SenXmlUtils::DecodeHttpCharactersLC(passwordProv);

   934                                 

   935                 if( ( username.Length() == 0 || username == ((CSenIdentityProvider&)aIdP).UserName() ) &&

   936                     ( decPasswordId->Length() == 0 || *decPasswordId ==  *decPasswordProv) )

   937                     {

   938                     aCredentials.AppendL(iCredentialArray[i]);

   939                     }

   940                 CleanupStack::PopAndDestroy(2); // encodehttp

   941                 }

   942             }

   943         }

   944         

   945     if ( aCredentials.Count() == 0 )

   946         {

   947         return KErrNotFound;

   948         }

   949         

   950     return KErrNone;

   951     }

   952 

   953 RSenCredentialPtr CSenCredentialManager::AddCredentialL(CSenInternalCredential* apCredential,

   954                                                         TInt& aErrorTo)

   955     {

   956     if ( !apCredential )

   957         {

   958         SENDEBUG_L("AddCredentialL(*) - Illegal argument: NULL");

   959         aErrorTo = KErrArgument;

   960         return RSenCredentialPtr();

   961         }

   962         

   963     CleanupStack::PushL(apCredential);

   964     RSenCredentialPtr credentialPtr;

   965     credentialPtr.OpenL(apCredential);

   966     CleanupStack::Pop(apCredential);

   967     CleanupClosePushL(credentialPtr);

   968     iCredentialArray.AppendL(credentialPtr);

   969     CleanupStack::Pop(&credentialPtr);

   970     

   971     TXmlEngElement element = this->AsElementL().AddNewElementL(KCredentialContainer);

   972     apCredential->IdentifierL().AsElementL().MoveTo(element);

   973     apCredential->IdentifierL().SetDocument(AsDocumentL());

   974     apCredential->IdentifierL().SetIdL(NextCredentialIdL());

   975     apCredential->PropertiesL().AsElementL().MoveTo(element);

   976     apCredential->PropertiesL().SetDocument(AsDocumentL());

   977     apCredential->AsElementL().MoveTo(element);

   978     apCredential->SetDocument(AsDocumentL());

   979     

   980     SaveCredentialDB();

   981     

   982     aErrorTo = KErrNone;

   983     return credentialPtr;

   984     }

   985 

   986 RSenCredentialPtr CSenCredentialManager::AddCredentialL( CSenIdentityProvider* apIdP,

   987 									                     CSenInternalCredential* apCredential,

   988 									                     TInt& aErrorTo )

   989     {

   990     CleanupStack::PushL(apCredential);

   991     CleanupStack::PushL(apIdP);

   992     

   993     if ( !apCredential )

   994         {

   995         SENDEBUG_L("AddCredentialL(*) - Illegal argument: NULL");

   996         CleanupStack::PopAndDestroy(apIdP);

   997         CleanupStack::PopAndDestroy(apCredential);

   998         return RSenCredentialPtr();

   999         }

  1000         

  1001     CSenIdentityProvider* pIdP = NULL;

  1002     // Note: Following function returns either KErrNotFound or the index of found

  1003     //       IdentityProvider (index >= 0).

  1004     TInt retVal = ((MSenIdentityManager&)iManager).FindMatchingIdentityProviderL(*apIdP, pIdP);

  1005     if ( retVal > KErrNone )

  1006         {

  1007         retVal = KErrNone;

  1008         }

  1009 

  1010     if ( retVal == KErrNotFound )

  1011         {

  1012         CleanupStack::PopAndDestroy(apIdP);

  1013         CleanupStack::PopAndDestroy(apCredential);

  1014         aErrorTo = retVal;

  1015         return RSenCredentialPtr();

  1016         }

  1017     else

  1018         {

  1019         CleanupStack::PopAndDestroy(apIdP);

  1020         TPtrC8 providerId = pIdP->ProviderID();

  1021         apCredential->SetIdentityProviderIdL(providerId);        

  1022         TPtrC8 userName = pIdP->UserName();

  1023         if(userName.Length() > 0)

  1024 	        {

  1025 			TPtrC8 password = pIdP->Password();	        	

  1026 			apCredential->SetAuthInfo(userName, password);        			

  1027 	        }        	

  1028         }

  1029         

  1030     RSenCredentialPtr credentialPtr;

  1031     credentialPtr.OpenL(apCredential);

  1032     CleanupStack::Pop(apCredential);

  1033     CleanupClosePushL(credentialPtr);

  1034     iCredentialArray.AppendL(credentialPtr);

  1035     CleanupStack::Pop(&credentialPtr);

  1036 

  1037 

  1038     TXmlEngElement element = this->AsElementL().AddNewElementL(KCredentialContainer);

  1039     apCredential->IdentifierL().AsElementL().MoveTo(element);

  1040     apCredential->IdentifierL().SetDocument(AsDocumentL());

  1041     apCredential->IdentifierL().SetIdL(NextCredentialIdL());

  1042     apCredential->PropertiesL().AsElementL().MoveTo(element);

  1043     apCredential->PropertiesL().SetDocument(AsDocumentL());

  1044     apCredential->AsElementL().MoveTo(element);

  1045     apCredential->SetDocument(AsDocumentL());

  1046     

  1047     SaveCredentialDB();

  1048     

  1049     aErrorTo = retVal;

  1050     return credentialPtr;

  1051     }

  1052 

  1053 RSenCredentialPtr CSenCredentialManager::AddCredentialL(const TDesC8& aCredential,

  1054                                                          TInt& aErrorTo)

  1055     {

  1056     CSenInternalCredential* pCredential = CSenInternalCredential::NewLC();

  1057     ipParser->ParseL(aCredential, *pCredential);

  1058     CleanupStack::Pop(pCredential);

  1059 

  1060     // Following takes the ownership of pCredential    

  1061     RSenCredentialPtr credPtr = AddCredentialL(pCredential, aErrorTo);

  1062     

  1063     return credPtr;

  1064     }

  1065 

  1066 RSenCredentialPtr CSenCredentialManager::AddCredentialL(CSenIdentityProvider* apIdP,

  1067 									                     const TDesC8& aCredential,

  1068 									                     TInt& aErrorTo)

  1069     {

  1070     CSenInternalCredential* pCredential = CSenInternalCredential::NewLC();

  1071     ipParser->ParseL(aCredential, *pCredential);

  1072     CleanupStack::Pop(pCredential);

  1073 

  1074     // Following takes the ownership of pCredential    

  1075     RSenCredentialPtr credPtr = AddCredentialL(apIdP, pCredential, aErrorTo);

  1076     

  1077     return credPtr;

  1078     }

  1079 

  1080 // Very efficient method that removes all the credentials of certain *service*,

  1081 // independent of provider ID and/or user account

  1082 TInt CSenCredentialManager::RemoveCredentialsL(const CSenWSDescription& aPattern)

  1083     {

  1084     TInt retVal(KErrNotFound);

  1085     

  1086     TInt count = iCredentialArray.Count();

  1087     for (TInt i=0; i<count; i++)

  1088         {

  1089         if ( iCredentialArray[i].Credential() && 

  1090              iCredentialArray[i].Credential()->IsApplicableL(aPattern) )

  1091             {

  1092             // Get CredentialContainer element

  1093             TXmlEngNode element = iCredentialArray[i].Credential()->AsElementL().ParentNode();

  1094             // Delete and destroy both CredentialIdentifier and Credential

  1095             iCredentialArray[i].CloseAndDestroyCredential();

  1096             // Delete and destroy CredentialContainer element

  1097             iCredentialArray.Remove(i);

  1098             element.Remove();

  1099             i--;

  1100             count--;

  1101             

  1102             retVal = KErrNone;

  1103             }

  1104         }

  1105 

  1106     SaveCredentialDB();

  1107         

  1108     return retVal;

  1109     }

  1110 

  1111 TInt CSenCredentialManager::RemoveCredentialsL( const CSenWSDescription& aPattern,

  1112 										        const CSenIdentityProvider& aIdP )

  1113     {

  1114     TInt retVal(KErrNotFound);

  1115     

  1116     TInt count = iCredentialArray.Count();

  1117     for (TInt i=0; i<count; i++)

  1118         {

  1119         if ( iCredentialArray[i].Credential() && 

  1120              iCredentialArray[i].Credential()->IsApplicableL(aPattern) )

  1121             {

  1122             TPtrC8 providerId;

  1123             retVal = iCredentialArray[i].Credential()->IdentityProviderIdL(providerId);

  1124             if ( retVal == KErrNone )

  1125                 {

  1126                 CSenWSDescription* pPattern = CSenWSDescription::NewLC();

  1127                 pPattern->SetEndPointL(providerId);

  1128                 CSenIdentityProvider* pProvider = iManager.IdentityProviderL(*pPattern);

  1129                 CleanupStack::PopAndDestroy(pPattern);

  1130                 /*if ( pProvider )                

  1131                     {

  1132                     if ( ( ((CSenIdentityProvider&)aIdP).UserName() == pProvider->UserName() ) &&

  1133                          ( ((CSenIdentityProvider&)aIdP).Password() == pProvider->Password() ) )

  1134                         {