1 /*

     2 * Copyright (c) 2006 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:   Implementation of DevCertOpenedKeySrv

    15 *

    16 */

    17 

    18 

    19 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    20 #include <mctkeystoreuids.h>

    21 #endif

    22 #include <asymmetric.h>

    23 #include <asymmetrickeys.h>

    24 #include <bigint.h>

    25 #include <ct.h>

    26 #include <securityerr.h>

    27 #include <e32base.h>

    28 

    29 #include "DevCertOpenedKeysSrv.h"

    30 #include "DevCertKeyStoreServer.h"

    31 #include "DevCertKeyStreamUtils.h"

    32 #include "DevTokenDataTypes.h"

    33 

    34 

    35 // ======== MEMBER FUNCTIONS ========

    36 

    37 // CDevCertOpenedKeySrv

    38 

    39 // ---------------------------------------------------------------------------

    40 // CDevCertOpenedKeySrv::NewL()

    41 // ---------------------------------------------------------------------------

    42 //

    43 CDevCertOpenedKeySrv* CDevCertOpenedKeySrv::NewL(const CDevCertKeyData& aKeyData, 

    44                                                  TUid aType, 

    45                                                  const RMessage2& aMessage,

    46                                                  CDevCertKeyDataManager& aKeyDataMan )

    47     {

    48     CDevCertOpenedKeySrv* self = NULL;

    49 

    50     if (aType == KRSARepudiableSignerUID)

    51         {

    52         self = new (ELeave) CDevCertRSARepudiableSignerSrv(aKeyData, aKeyDataMan );

    53         }

    54     else if (aType == KDSARepudiableSignerUID)

    55         {

    56         self = new (ELeave) CDevCertDSARepudiableSignerSrv(aKeyData, aKeyDataMan );

    57         }

    58     else if (aType == KPrivateDecryptorUID)

    59         {

    60         self = new (ELeave) CDevCertRSADecryptorSrv(aKeyData, aKeyDataMan );

    61         }

    62     else if (aType == KKeyAgreementUID)

    63         {

    64         self = new (ELeave) CDevCertDHAgreementSrv(aKeyData, aKeyDataMan );

    65         }

    66     else

    67         {

    68         User::Invariant();

    69         }

    70 

    71     CleanupStack::PushL(self);

    72     self->ConstructL(aMessage);

    73     CleanupStack::Pop(self);

    74     return self;

    75     }

    76 

    77 

    78 // ---------------------------------------------------------------------------

    79 // CDevCertOpenedKeySrv::CDevCertOpenedKeySrv()

    80 // ---------------------------------------------------------------------------

    81 //

    82 CDevCertOpenedKeySrv::CDevCertOpenedKeySrv(const CDevCertKeyData& aKeyData, CDevCertKeyDataManager& aKeyDataMan ) :

    83   CActive(EPriorityStandard),

    84   iKeyData(aKeyData),

    85   iKeyDataMan(aKeyDataMan)

    86     {

    87     }

    88 

    89 

    90 // ---------------------------------------------------------------------------

    91 // CDevCertOpenedKeySrv::ConstructL()

    92 // ---------------------------------------------------------------------------

    93 //

    94 void CDevCertOpenedKeySrv::ConstructL(const RMessage2& aMessage)

    95     {

    96     CDevTokenKeyInfo* keyInfo = iKeyDataMan.ReadKeyInfoLC(iKeyData);  

    97     CheckKeyL(*keyInfo, aMessage);

    98     iLabel = keyInfo->Label().AllocL();

    99     CleanupStack::PopAndDestroy(keyInfo);

   100     CActiveScheduler::Add(this);

   101     }

   102 

   103 

   104 // ---------------------------------------------------------------------------

   105 // CDevCertOpenedKeySrv::~CDevCertOpenedKeySrv()

   106 // ---------------------------------------------------------------------------

   107 //

   108 CDevCertOpenedKeySrv::~CDevCertOpenedKeySrv()

   109     {

   110     Cancel();

   111     delete iLabel;

   112     }

   113 

   114 

   115 // ---------------------------------------------------------------------------

   116 // CDevCertOpenedKeySrv::Label()

   117 // ---------------------------------------------------------------------------

   118 //

   119 const TDesC& CDevCertOpenedKeySrv::Label() const

   120     {

   121     return *iLabel;

   122     }

   123 

   124 

   125 // ---------------------------------------------------------------------------

   126 // CDevCertOpenedKeySrv::Handle()

   127 // ---------------------------------------------------------------------------

   128 //

   129 TInt CDevCertOpenedKeySrv::Handle() const

   130     {

   131     return iKeyData.Handle();

   132     }

   133 

   134 

   135 // ---------------------------------------------------------------------------

   136 // CDevCertOpenedKeySrv::CheckKeyL()

   137 // ---------------------------------------------------------------------------

   138 //

   139 void CDevCertOpenedKeySrv::CheckKeyL(const CDevTokenKeyInfo& aKeyInfo, const RMessage2& aMessage)

   140     {

   141     // Check the client is allowed to use the key

   142     if (!aKeyInfo.UsePolicy().CheckPolicy(aMessage))

   143         {

   144         User::Leave(KErrPermissionDenied);

   145         }

   146 

   147     // Check that the operation represented by this object is supported for this

   148     // type of key

   149     if (aKeyInfo.Algorithm() != Algorithm())

   150         {

   151         User::Leave(KErrKeyAlgorithm);

   152         }

   153 

   154     // Check the key usage allows the operation

   155     if ((aKeyInfo.Usage() & RequiredUsage()) == 0)

   156         {

   157         User::Leave(KErrKeyUsage);

   158         }

   159 

   160     // Check current time is after start date (if set) and before end date (if

   161     // set)

   162     TTime timeNow;

   163     timeNow.UniversalTime();

   164     if (aKeyInfo.StartDate().Int64() != 0 && timeNow < aKeyInfo.StartDate())

   165         {

   166         User::Leave(KErrKeyValidity);

   167         }

   168     if (aKeyInfo.EndDate().Int64() != 0 && timeNow >= aKeyInfo.EndDate())

   169         {

   170         User::Leave(KErrKeyValidity);

   171         }

   172     }

   173 

   174 

   175 // ---------------------------------------------------------------------------

   176 // CDevCertOpenedKeySrv::DoOperation()

   177 // ---------------------------------------------------------------------------

   178 //

   179 void CDevCertOpenedKeySrv::DoOperation( TRequestStatus& aStatus )

   180     {

   181     ASSERT(iState == EIdle);

   182     iStatus = KRequestPending;

   183     iClientStatus = &aStatus;

   184     TRequestStatus* status = &iStatus;

   185     iState = EOperation;

   186     SetActive();

   187     User::RequestComplete( status, KErrNone );

   188     }   

   189 

   190 

   191 // ---------------------------------------------------------------------------

   192 // CDevCertOpenedKeySrv::RunL()

   193 // ---------------------------------------------------------------------------

   194 //

   195 void CDevCertOpenedKeySrv::RunL()

   196     {

   197     User::LeaveIfError(iStatus.Int());

   198 

   199     switch (iState)

   200         {

   201         case EOperation:

   202         if (!iKeyRead)

   203             {

   204             RStoreReadStream stream;

   205             iKeyDataMan.OpenPrivateDataStreamLC(iKeyData, stream);

   206             ReadPrivateKeyL(stream);

   207             CleanupStack::PopAndDestroy(&stream);

   208             iKeyRead = ETrue;

   209             }

   210         PerformOperationL();

   211         break;

   212 

   213         default:

   214         ASSERT(EFalse);

   215         }

   216 

   217     Complete(KErrNone);

   218     }

   219 

   220 

   221 // ---------------------------------------------------------------------------

   222 // CDevCertOpenedKeySrv::RunError()

   223 // ---------------------------------------------------------------------------

   224 //

   225 TInt CDevCertOpenedKeySrv::RunError(TInt aError)

   226     {

   227     Complete(aError);

   228     return KErrNone;

   229     }

   230 

   231 

   232 // ---------------------------------------------------------------------------

   233 // CDevCertOpenedKeySrv::DoCancel()

   234 // ---------------------------------------------------------------------------

   235 //

   236 void CDevCertOpenedKeySrv::DoCancel()

   237     {

   238     Complete(KErrCancel);

   239     }

   240 

   241 

   242 // ---------------------------------------------------------------------------

   243 // CDevCertOpenedKeySrv::Complete()

   244 // ---------------------------------------------------------------------------

   245 //

   246 void CDevCertOpenedKeySrv::Complete(TInt aError)

   247     {

   248     Cleanup();

   249     if (iClientStatus)

   250         {

   251         User::RequestComplete(iClientStatus, aError);

   252         }

   253     iState = EIdle;

   254     }

   255 

   256 

   257 

   258 // CDevCertRSARepudiableSignerSrv 

   259 

   260 // ---------------------------------------------------------------------------

   261 // CDevCertRSARepudiableSignerSrv::CDevCertRSARepudiableSignerSrv()

   262 // ---------------------------------------------------------------------------

   263 //

   264 CDevCertRSARepudiableSignerSrv::CDevCertRSARepudiableSignerSrv(const CDevCertKeyData& aKeyData, CDevCertKeyDataManager& aKeyDataMan ) :

   265   CDevCertOpenedKeySrv(aKeyData, aKeyDataMan )

   266     {

   267     }

   268 

   269 

   270 // ---------------------------------------------------------------------------

   271 // CDevCertRSARepudiableSignerSrv::~CDevCertRSARepudiableSignerSrv()

   272 // ---------------------------------------------------------------------------

   273 //

   274 CDevCertRSARepudiableSignerSrv::~CDevCertRSARepudiableSignerSrv()

   275     {

   276     delete iPrivateKey;

   277     }

   278 

   279 

   280 // ---------------------------------------------------------------------------

   281 // CDevCertRSARepudiableSignerSrv::Type()

   282 // ---------------------------------------------------------------------------

   283 //

   284 TUid CDevCertRSARepudiableSignerSrv::Type() const

   285     {

   286     return KRSARepudiableSignerUID;

   287     }

   288 

   289 

   290 // ---------------------------------------------------------------------------

   291 // CDevCertRSARepudiableSignerSrv::Algorithm()

   292 // ---------------------------------------------------------------------------

   293 //

   294 CDevTokenKeyInfo::EKeyAlgorithm CDevCertRSARepudiableSignerSrv::Algorithm() const

   295     {

   296     return CDevTokenKeyInfo::ERSA;

   297     }

   298 

   299 

   300 // ---------------------------------------------------------------------------

   301 // CDevCertRSARepudiableSignerSrv::RequiredUsage()

   302 // ---------------------------------------------------------------------------

   303 //

   304 TKeyUsagePKCS15 CDevCertRSARepudiableSignerSrv::RequiredUsage() const

   305     {

   306     return EPKCS15UsageSignSignRecover;

   307     }

   308 

   309 

   310 // ---------------------------------------------------------------------------

   311 // CDevCertRSARepudiableSignerSrv::Sign()

   312 // ---------------------------------------------------------------------------

   313 //

   314 void CDevCertRSARepudiableSignerSrv::Sign(const TDesC8& aPlaintext,

   315                 CRSASignature*& aSignature,

   316                 TRequestStatus& aStatus)

   317     {

   318     ASSERT( iPlaintext.Ptr() == NULL );

   319     ASSERT( iSignaturePtr == NULL );

   320     iPlaintext.Set(aPlaintext);

   321     iSignaturePtr = &aSignature;

   322     DoOperation( aStatus );

   323     }

   324 

   325 

   326 // ---------------------------------------------------------------------------

   327 // CDevCertRSARepudiableSignerSrv::ReadPrivateKeyL()

   328 // ---------------------------------------------------------------------------

   329 //

   330 void CDevCertRSARepudiableSignerSrv::ReadPrivateKeyL(RReadStream& aStream)

   331     {

   332     ASSERT( iPrivateKey == NULL );

   333     CreateL(aStream, iPrivateKey);

   334     }

   335 

   336 

   337 // ---------------------------------------------------------------------------

   338 // CDevCertRSARepudiableSignerSrv::PerformOperationL()

   339 // ---------------------------------------------------------------------------

   340 //

   341 void CDevCertRSARepudiableSignerSrv::PerformOperationL()

   342     {

   343     ASSERT(iPrivateKey);

   344 

   345     CRSAPKCS1v15Signer* signer = CRSAPKCS1v15Signer::NewLC(*iPrivateKey);

   346     const CRSASignature* signature = signer->SignL(iPlaintext);

   347     CleanupStack::PopAndDestroy(signer);

   348     *iSignaturePtr = const_cast<CRSASignature*>(signature);

   349     }

   350 

   351 

   352 // ---------------------------------------------------------------------------

   353 // CDevCertRSARepudiableSignerSrv::Cleanup()

   354 // ---------------------------------------------------------------------------

   355 //

   356 void CDevCertRSARepudiableSignerSrv::Cleanup()

   357     {

   358     iPlaintext.Set(NULL, 0);

   359     iSignaturePtr = NULL;

   360     }

   361 

   362 

   363 // CDevCertDSARepudiableSignerSrv 

   364 

   365 // ---------------------------------------------------------------------------

   366 // CDevCertDSARepudiableSignerSrv::CDevCertDSARepudiableSignerSrv()

   367 // ---------------------------------------------------------------------------

   368 //

   369 CDevCertDSARepudiableSignerSrv::CDevCertDSARepudiableSignerSrv(const CDevCertKeyData& aKeyData, CDevCertKeyDataManager& aKeyDataMan ) :

   370   CDevCertOpenedKeySrv(aKeyData, aKeyDataMan )

   371     {

   372     }

   373 

   374 

   375 // ---------------------------------------------------------------------------

   376 // CDevCertDSARepudiableSignerSrv::~CDevCertDSARepudiableSignerSrv()

   377 // ---------------------------------------------------------------------------

   378 //

   379 CDevCertDSARepudiableSignerSrv::~CDevCertDSARepudiableSignerSrv()

   380     {

   381     delete iPrivateKey;

   382     }

   383 

   384 

   385 // ---------------------------------------------------------------------------

   386 // CDevCertDSARepudiableSignerSrv::Type()

   387 // ---------------------------------------------------------------------------

   388 //

   389 TUid CDevCertDSARepudiableSignerSrv::Type() const

   390     {

   391     return KDSARepudiableSignerUID;

   392     }

   393 

   394 

   395 // ---------------------------------------------------------------------------

   396 // CDevCertDSARepudiableSignerSrv::Algorithm()

   397 // ---------------------------------------------------------------------------

   398 //

   399 CDevTokenKeyInfo::EKeyAlgorithm CDevCertDSARepudiableSignerSrv::Algorithm() const

   400     {

   401     return CDevTokenKeyInfo::EDSA;

   402     }

   403 

   404 

   405 // ---------------------------------------------------------------------------

   406 // CDevCertDSARepudiableSignerSrv::RequiredUsage()

   407 // ---------------------------------------------------------------------------

   408 //

   409 TKeyUsagePKCS15 CDevCertDSARepudiableSignerSrv::RequiredUsage() const

   410     {

   411     return EPKCS15UsageSignSignRecover;

   412     }

   413 

   414 

   415 // ---------------------------------------------------------------------------

   416 // CDevCertDSARepudiableSignerSrv::Sign()

   417 // ---------------------------------------------------------------------------

   418 //

   419 void CDevCertDSARepudiableSignerSrv::Sign(const TDesC8& aPlaintext,

   420                 CDSASignature*& aSignature,

   421                 TRequestStatus& aStatus)

   422     {

   423     ASSERT( iPlaintext.Ptr() == NULL );

   424     ASSERT( iSignaturePtr == NULL );

   425     iPlaintext.Set(aPlaintext);

   426     iSignaturePtr = &aSignature;

   427     DoOperation( aStatus );

   428     }

   429 

   430 

   431 // ---------------------------------------------------------------------------

   432 // CDevCertDSARepudiableSignerSrv::ReadPrivateKeyL()

   433 // ---------------------------------------------------------------------------

   434 //

   435 void CDevCertDSARepudiableSignerSrv::ReadPrivateKeyL(RReadStream& aStream)

   436     {

   437     ASSERT( iPrivateKey == NULL );

   438     CreateL(aStream, iPrivateKey);

   439     }

   440 

   441 

   442 // ---------------------------------------------------------------------------

   443 // CDevCertDSARepudiableSignerSrv::PerformOperationL()

   444 // ---------------------------------------------------------------------------

   445 //

   446 void CDevCertDSARepudiableSignerSrv::PerformOperationL()

   447     {

   448     ASSERT( iPrivateKey );

   449 

   450     CDSASigner* signer = CDSASigner::NewLC(*iPrivateKey);

   451     const CDSASignature* signature = signer->SignL(iPlaintext);

   452     CleanupStack::PopAndDestroy(signer);

   453     *iSignaturePtr = const_cast<CDSASignature*>(signature);

   454     }

   455 

   456 

   457 // ---------------------------------------------------------------------------

   458 // CDevCertDSARepudiableSignerSrv::Cleanup()

   459 // ---------------------------------------------------------------------------

   460 //

   461 void CDevCertDSARepudiableSignerSrv::Cleanup()

   462     {

   463     iPlaintext.Set(NULL, 0);

   464     iSignaturePtr = NULL;

   465     }

   466 

   467 

   468 // CDevCertRSADecryptorSrv 

   469 

   470 // ---------------------------------------------------------------------------

   471 // CDevCertRSADecryptorSrv::CDevCertRSADecryptorSrv()

   472 // ---------------------------------------------------------------------------

   473 //

   474 CDevCertRSADecryptorSrv::CDevCertRSADecryptorSrv(const CDevCertKeyData& aKeyData, CDevCertKeyDataManager& aKeyDataMan ) :

   475   CDevCertOpenedKeySrv(aKeyData, aKeyDataMan )

   476     {

   477     }

   478 

   479 

   480 // ---------------------------------------------------------------------------

   481 // CDevCertRSADecryptorSrv::~CDevCertRSADecryptorSrv()

   482 // ---------------------------------------------------------------------------

   483 //

   484 CDevCertRSADecryptorSrv::~CDevCertRSADecryptorSrv()

   485     {

   486     delete iPrivateKey;

   487     }

   488 

   489 

   490 // ---------------------------------------------------------------------------

   491 // CDevCertRSADecryptorSrv::Type()

   492 // ---------------------------------------------------------------------------

   493 //

   494 TUid CDevCertRSADecryptorSrv::Type() const

   495     {

   496     return KPrivateDecryptorUID;

   497     }

   498 

   499 

   500 // ---------------------------------------------------------------------------

   501 // CDevCertRSADecryptorSrv::Algorithm()

   502 // ---------------------------------------------------------------------------

   503 //

   504 CDevTokenKeyInfo::EKeyAlgorithm CDevCertRSADecryptorSrv::Algorithm() const

   505     {

   506     return CDevTokenKeyInfo::ERSA;

   507     }

   508 

   509 

   510 // ---------------------------------------------------------------------------

   511 // CDevCertRSADecryptorSrv::RequiredUsage()

   512 // ---------------------------------------------------------------------------

   513 //

   514 TKeyUsagePKCS15 CDevCertRSADecryptorSrv::RequiredUsage() const

   515     {

   516     return EPKCS15UsageDecryptUnwrap;

   517     }

   518 

   519 

   520 // ---------------------------------------------------------------------------

   521 // CDevCertRSADecryptorSrv::Decrypt()

   522 // ---------------------------------------------------------------------------

   523 //

   524 void CDevCertRSADecryptorSrv::Decrypt(const TDesC8& aCiphertext,

   525                 HBufC8*& aPlaintext,

   526                 TRequestStatus& aStatus)

   527     {

   528     ASSERT( iCiphertext.Ptr() == NULL );

   529     ASSERT( iPlaintextPtr == NULL );

   530     iCiphertext.Set(aCiphertext);

   531     iPlaintextPtr = &aPlaintext;

   532     DoOperation( aStatus );

   533     }

   534 

   535 

   536 // ---------------------------------------------------------------------------

   537 // CDevCertRSADecryptorSrv::ReadPrivateKeyL()

   538 // ---------------------------------------------------------------------------

   539 //

   540 void CDevCertRSADecryptorSrv::ReadPrivateKeyL(RReadStream& aStream)

   541     {

   542     ASSERT( iPrivateKey == NULL );

   543     CreateL(aStream, iPrivateKey);

   544     }

   545 

   546 

   547 // ---------------------------------------------------------------------------

   548 // CDevCertRSADecryptorSrv::PerformOperationL()

   549 // ---------------------------------------------------------------------------

   550 //

   551 void CDevCertRSADecryptorSrv::PerformOperationL()

   552     {

   553     ASSERT(iPrivateKey);

   554 

   555     CRSAPKCS1v15Decryptor* decryptor = CRSAPKCS1v15Decryptor::NewLC(*iPrivateKey);

   556     HBufC8* plaintext = HBufC8::NewMaxLC(decryptor->MaxOutputLength());

   557     TPtr8 ptr = plaintext->Des();

   558     decryptor->DecryptL(iCiphertext, ptr);

   559 

   560     *iPlaintextPtr = plaintext;

   561     CleanupStack::Pop(plaintext); // now owned by client

   562     CleanupStack::PopAndDestroy(decryptor);

   563     }

   564 

   565 

   566 // ---------------------------------------------------------------------------

   567 // CDevCertRSADecryptorSrv::Cleanup()

   568 // ---------------------------------------------------------------------------

   569 //

   570 void CDevCertRSADecryptorSrv::Cleanup()

   571     {

   572     iCiphertext.Set(NULL, 0);

   573     iPlaintextPtr = NULL;

   574     }

   575 

   576 

   577 // CDevCertDHAgreementSrv 

   578 

   579 // ---------------------------------------------------------------------------

   580 // CDevCertDHAgreementSrv::CDevCertDHAgreementSrv()

   581 // ---------------------------------------------------------------------------

   582 //

   583 CDevCertDHAgreementSrv::CDevCertDHAgreementSrv(const CDevCertKeyData& aKeyData, CDevCertKeyDataManager& aKeyDataMan ) :

   584   CDevCertOpenedKeySrv(aKeyData, aKeyDataMan )

   585     {

   586     }

   587 

   588 

   589 // ---------------------------------------------------------------------------

   590 // CDevCertDHAgreementSrv::~CDevCertDHAgreementSrv()

   591 // ---------------------------------------------------------------------------

   592 //

   593 CDevCertDHAgreementSrv::~CDevCertDHAgreementSrv()

   594     {

   595     iKey.Close();

   596     }

   597 

   598 

   599 // ---------------------------------------------------------------------------

   600 // CDevCertDHAgreementSrv::Type()

   601 // ---------------------------------------------------------------------------

   602 //

   603 TUid CDevCertDHAgreementSrv::Type() const

   604     {

   605     return KKeyAgreementUID;

   606     }

   607 

   608 

   609 // ---------------------------------------------------------------------------

   610 // CDevCertDHAgreementSrv::Algorithm()

   611 // ---------------------------------------------------------------------------

   612 //

   613 CDevTokenKeyInfo::EKeyAlgorithm CDevCertDHAgreementSrv::Algorithm() const

   614     {

   615     return CDevTokenKeyInfo::EDH;

   616     }

   617 

   618 

   619 // ---------------------------------------------------------------------------

   620 // CDevCertDHAgreementSrv::RequiredUsage()

   621 // ---------------------------------------------------------------------------

   622 //

   623 TKeyUsagePKCS15 CDevCertDHAgreementSrv::RequiredUsage() const

   624     {

   625     return EPKCS15UsageDerive;

   626     }

   627 

   628 

   629 // ---------------------------------------------------------------------------

   630 // CDevCertDHAgreementSrv::PublicKey()

   631 // ---------------------------------------------------------------------------

   632 //

   633 void CDevCertDHAgreementSrv::PublicKey(CDevTokenDHParams& aParameters, RInteger& aPublicKey, TRequestStatus& aStatus)

   634     {

   635     ASSERT( iPKParams == NULL );

   636     ASSERT( iPKPublicKeyPtr == NULL );

   637     iPKParams = &aParameters;

   638     iPKPublicKeyPtr = &aPublicKey;

   639     iDHState = EPublicKey;

   640     DoOperation( aStatus );

   641     }

   642 

   643 

   644 // ---------------------------------------------------------------------------

   645 // CDevCertDHAgreementSrv::Agree()

   646 // ---------------------------------------------------------------------------

   647 //

   648 void CDevCertDHAgreementSrv::Agree(CDHPublicKey& aY, HBufC8*& aAgreedKey, TRequestStatus& aStatus)

   649     {

   650     ASSERT( iAKPublicKey == NULL );

   651     ASSERT( iAKAgreedKeyPtr == NULL );

   652     iAKPublicKey = &aY;

   653     iAKAgreedKeyPtr = &aAgreedKey;

   654     iDHState = EAgree;

   655     DoOperation( aStatus );

   656     }

   657 

   658 

   659 // ---------------------------------------------------------------------------

   660 // CDevCertDHAgreementSrv::ReadPrivateKeyL()

   661 // ---------------------------------------------------------------------------

   662 //

   663 void CDevCertDHAgreementSrv::ReadPrivateKeyL(RReadStream& aStream)

   664     {

   665     CreateLC(aStream, iKey);

   666     CleanupStack::Pop(&iKey);

   667     }

   668 

   669 

   670 // ---------------------------------------------------------------------------

   671 // CDevCertDHAgreementSrv::PerformOperationL()

   672 // ---------------------------------------------------------------------------

   673 //

   674 void CDevCertDHAgreementSrv::PerformOperationL()

   675     {

   676     switch (iDHState)

   677         {

   678         case EPublicKey:

   679         DoPublicKeyL();

   680         break;

   681         case EAgree:

   682         DoAgreeL();

   683         break;

   684         default:

   685         ASSERT(FALSE);

   686         }

   687     }

   688 

   689 

   690 // ---------------------------------------------------------------------------

   691 // CDevCertDHAgreementSrv::DoPublicKeyL()

   692 // ---------------------------------------------------------------------------

   693 //

   694 void CDevCertDHAgreementSrv::DoPublicKeyL()

   695     {

   696     ASSERT(iPKParams);

   697     ASSERT(iPKPublicKeyPtr);

   698 

   699     RInteger n = iPKParams->TakeN();

   700     CleanupStack::PushL(n);

   701     RInteger g = iPKParams->TakeG();

   702     CleanupStack::PushL(g);

   703     RInteger x = RInteger::NewL(iKey);

   704     CleanupStack::PushL(x);

   705     CDHKeyPair* keyPair = CDHKeyPair::NewL(n, g, x);

   706     CleanupStack::Pop(3); // x, g, n

   707     CleanupStack::PushL(keyPair);

   708 

   709     const CDHPublicKey& pubKey = keyPair->PublicKey();

   710     *iPKPublicKeyPtr = RInteger::NewL(pubKey.X());

   711     CleanupStack::PopAndDestroy(keyPair);

   712     }

   713 

   714 

   715 // ---------------------------------------------------------------------------

   716 // CDevCertDHAgreementSrv::DoAgreeL()

   717 // ---------------------------------------------------------------------------

   718 //

   719 void CDevCertDHAgreementSrv::DoAgreeL()

   720     {

   721     ASSERT(iAKPublicKey);

   722     ASSERT(iAKAgreedKeyPtr);

   723 

   724     RInteger n = RInteger::NewL(iAKPublicKey->N());

   725     CleanupStack::PushL(n);

   726     RInteger g = RInteger::NewL(iAKPublicKey->G());

   727     CleanupStack::PushL(g);

   728     RInteger x = RInteger::NewL(iKey);

   729     CleanupStack::PushL(x);

   730     CDHPrivateKey* privKey = CDHPrivateKey::NewL(n, g, x);

   731     CleanupStack::Pop(3); // x, g, n

   732     CleanupStack::PushL(privKey);

   733     CDH* dh = CDH::NewLC(*privKey);

   734     *iAKAgreedKeyPtr = const_cast<HBufC8*>(dh->AgreeL(*iAKPublicKey));

   735     CleanupStack::PopAndDestroy(2, privKey);

   736     }

   737 

   738 

   739 // ---------------------------------------------------------------------------

   740 // CDevCertDHAgreementSrv::Cleanup()

   741 // ---------------------------------------------------------------------------

   742 //

   743 void CDevCertDHAgreementSrv::Cleanup()

   744     {

   745     iPKParams = NULL;

   746     iPKPublicKeyPtr = NULL;

   747     iAKPublicKey = NULL;

   748     iAKAgreedKeyPtr = NULL;

   749     iDHState = EIdle;

   750     }

   751 

   752 //EOF

   753 

   754