1 /*

     2 * Copyright (c) 2003-2008 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:  This class declares the interface of class CDRMDbSession.

    15 *

    16 */

    17 

    18 

    19 #ifndef CDRMDBSESSION_H

    20 #define CDRMDBSESSION_H

    21 

    22 //  INCLUDES

    23 #include <e32base.h>

    24 #include <caf/caf.h>

    25 #include "DRMTypes.h"

    26 #include "DRMConstraint.h"

    27 #include "DRMEngineClientServer.h"

    28 #include "drmcommonclientserver.h"

    29 #include "drmenginetypedefs.h"

    30 #include "roapstorageclient.h"

    31 

    32 // CONSTANTS

    33 // MACROS

    34 // FUNCTION PROTOTYPES

    35 // FORWARD DECLARATIONS

    36 class CDRMParentStorage;

    37 

    38 class CDRMConsume;

    39 class CDRMPermission;

    40 class CDRMNotifier;

    41 class CDRMObsoleteFinder;

    42 

    43 // DATA TYPES

    44 // CLASS DECLARATION

    45 

    46 /**

    47 *  Server side instance of DRM Rights Database session.

    48 *  This class is the server side instance of C/S communications of a certain

    49 *  session.

    50 *

    51 *  @lib RightsServer.exe

    52 *  @since S60Rel2.5

    53 */

    54 NONSHARABLE_CLASS( CDRMDbSession ) : public CSession2

    55     {

    56 public:  // Constructors and destructor

    57 

    58     /**

    59     * Two-phased constructor.

    60     * @since S60Rel2.6

    61     * @return New session instance.

    62     */

    63     static CDRMDbSession* NewL();

    64 

    65    /**

    66     * Destructor.

    67     * @since S60Rel2.5

    68     */

    69    virtual ~CDRMDbSession();

    70 

    71 public: // Functions from base classes

    72 

    73     /**

    74     * From CSession2: Handles the service request event.

    75     * @since S60Rel2.6

    76     * @param aMessage The message related to the event.

    77     * @exception Method leaves with appropriate exception value

    78     *            if any errors occured.

    79     */

    80     void ServiceL( const RMessage2& aMessage );

    81 

    82     /**

    83     * From CSession2: Handles the errors from ServiceL if encountered.

    84     * @since S60Rel3.0

    85     * @param aMessage The message related to the event.

    86     * @param aError   Error code.

    87     */

    88     virtual void ServiceError( const RMessage2& aMessage,

    89                                TInt aError );

    90 

    91 public: // New functions

    92 

    93    void AsyncOperationDone();

    94 

    95    void AsyncOperationDone( TFileName* aFileName );

    96 

    97     /**

    98     * This method tries to find a suitable rights object

    99     * from the given list which allows the specified intent.

   100     * @since S60Rel3.0

   101     * @param aIntent Intent.

   102     * @param aRights List of rights objects.

   103     * @param aParent Out-parameter: related parent permission. The caller

   104     *                owns the parent.

   105     * @param aUpdate Out-parameter: whether to update the rights object

   106     * (if one is found).

   107     * @return Symbian error or CAF error. KErrNone if everything goes

   108     *         properly

   109     */

   110     TInt FindRightsObject( const ContentAccess::TIntent aIntent,

   111                            const TDesC8& aURI,

   112                            CDRMPermission*& aChild,

   113                            HBufC8*& aUsedURI,

   114                            TUint32& aReason );

   115 

   116     /**

   117     * Check whether the identified permission allows the caller to get

   118     * decrypted data. Enforces e.g. capability checking

   119     *

   120     * @param aContentId Content ID of the content, can be NULL

   121     * @param aPermission Permission which grants access, can be NULL

   122     * @param aIntent Consumption intent

   123     * @return KErrAccessDenied if the caller does not have sufficient

   124     *         credentials, KErrNone if access is granted, or other

   125     *         Symbian errors

   126     */

   127     TInt VerifyCredentials( HBufC8* aContentId,

   128                             CDRMPermission* aPermission,

   129                             TIntent aIntent );

   130 

   131     /**

   132     * Return the SID of the client

   133     * @return SID of the client

   134     */

   135     TUid GetClientSid();

   136 

   137     /**

   138     * Return the VID of the client

   139     * @return VID of the client

   140     */

   141     TUid GetClientVid();

   142 

   143     /**

   144     * Return if the client has sufficient DRM capability

   145     * @return ETrue if the capability is available, EFalse otherwise

   146     */

   147     TBool ClientHasCapability();

   148 

   149     /**

   150     * This method returns handle to the Roap storage client.

   151     *

   152     * @since S60 3.2

   153     * @return Handle to the Roap storage client

   154     */

   155     Roap::RRoapStorageClient& RoapClient();

   156 

   157     /**

   158     * This method connects the roap client, does nothing if it's already connected

   159     *

   160     * @since S60 3.2

   161     * @return Handle to the Roap storage client

   162     */

   163     TInt ConnectRoapClient();

   164 

   165 protected:  // New functions

   166 

   167 protected:  // Functions from base classes

   168 

   169 private:

   170 

   171     enum TProtectionType

   172         {

   173         ENoProtection,

   174         EPublicKey,

   175         EDomainKey,

   176         };

   177 

   178     enum TCredentialsCheckType

   179         {

   180         ENotChecked,

   181         ECheckedAndAllowed,

   182         ECheckedAndDenied,

   183         };

   184 

   185     /**

   186     * C++ constructor.

   187     * @since S60Rel2.6

   188     */

   189     CDRMDbSession();

   190 

   191     /**

   192     * Second phase constructor.

   193     * @since S60Rel2.6

   194     */

   195     void ConstructL();

   196 

   197     /**

   198     * Helper function for ServiceL().

   199     * @since S60Rel2.5

   200     * @param aMessage The message associated to the event.

   201     */

   202     void AddRecordL( const RMessage2& aMessage,

   203                      TProtectionType aProtection );

   204 

   205     /**

   206     * Helper function for ServiceL().

   207     * @since S60Rel2.5

   208     * @param aMessage The message associated to the event.

   209     */

   210     void GetRecordL( const RMessage2& aMessage );

   211 

   212     /**

   213     * Helper function for ServiceL().

   214     * @since S60Rel2.5

   215     * @param aMessage The message associated to the event.

   216     */

   217     void GetEntryListL( const RMessage2& aMessage );

   218 

   219     /**

   220     * Helper function for ServiceL().

   221     * @since S60Rel2.5

   222     * @param aMessage The message associated to the event.

   223     */

   224     void DeleteL( const RMessage2& aMessage );

   225 

   226     /**

   227     * Helper function for ServiceL().

   228     * @since S60Rel2.5

   229     * @param aMessage The message associated to the event.

   230     */

   231     void DeleteRecordL( const RMessage2& aMessage );

   232 

   233     /**

   234     * Helper function for ServiceL().

   235     * @since S60Rel2.5

   236     * @param aMessage The message associated to the event.

   237     */

   238     void ExportCIDsL( const RMessage2& aMessage );

   239 

   240     /**

   241     * Helper function for ServiceL().

   242     * @since S60Rel2.5

   243     * @param aMessage The message associated to the event.

   244     */

   245     void GetKeyL( const RMessage2& aMessage );

   246 

   247     /**

   248     * Helper function for ServiceL().

   249     * @since S60Rel2.5

   250     * @param aMessage The message associated to the event.

   251     */

   252     void CheckRightsL( const RMessage2& aMessage );

   253 

   254     /**

   255     * Helper function for ServiceL().

   256     * @since S60Rel2.5

   257     * @param aMessage The message associated to the event.

   258     */

   259     void CountL( const RMessage2& aMessage );

   260 

   261     /**

   262     * Implementation of DeleteAll() command.

   263     * @since 2.5

   264     * @param aMessage The message associated to the event.

   265     */

   266     void DeleteAllL( const RMessage2& aMessage );

   267 

   268     /**

   269     * Implementation of ConsumeL() command.

   270     * @since 2.5

   271     * @param aMessage The message associated to the event.

   272     */

   273     void ConsumeL( const RMessage2& aMessage );

   274 

   275     /**

   276     * Check if Consume is possible

   277     * @since 3.0

   278     * @param aMessage The message associated to the event.

   279     */

   280     void CheckConsumeL( const RMessage2& aMessage );

   281 

   282     /**

   283     * Calculate the padding using a given data block

   284     * @since 2.5

   285     * @param aMessage The message associated to the event.

   286     */

   287     void CalculatePaddingL( const RMessage2& aMessage );

   288 

   289     /**

   290     * Give secure time & trust level to the client.

   291     * @since 2.6

   292     * @params aMessage The message associated to the event.

   293     */

   294     void SecureTimeL( const RMessage2& aMessage );

   295 

   296     /**

   297     * Encrypt data using the session key

   298     * @since 3.0

   299     * @params aMessage The message associated to the event.

   300     */

   301     void EncryptL( const RMessage2& aMessage );

   302 

   303     /**

   304     * Decrypt data using the session key

   305     * @since 3.0

   306     * @params aMessage The message associated to the event.

   307     */

   308     void DecryptL( const RMessage2& aMessage );

   309 

   310     /**

   311     * Initialize the session key

   312     * @since 3.0

   313     * @params aMessage The message associated to the event.

   314     */

   315     void InitializeKeyL( const RMessage2& aMessage );

   316 

   317     /**

   318     * Initialize the session key from a group key

   319     * @since 3.0

   320     * @params aMessage The message associated to the event.

   321     */

   322     void InitializeGroupKeyL( const RMessage2& aMessage );

   323 

   324     /**

   325     * Return the prepared data to the client.

   326     * @since 3.0

   327     * @params aMessage The message associated to the event.

   328     */

   329     void GetPreparedDataL( const RMessage2& aMessage );

   330 

   331     /**

   332     * Return the prepared data to the client.

   333     * @since 3.0

   334     * @params aMessage The message associated to the event.

   335     */

   336     void AddDomainROL( const RMessage2& aMessage );

   337 

   338     /**

   339     * Return the prepared data to the client.

   340     * @since 3.0

   341     * @params aMessage The message associated to the event.

   342     */

   343     void GetDomainROL( const RMessage2& aMessage );

   344 

   345     /**

   346     * Return the prepared data to the client.

   347     * @since 3.0

   348     * @params aMessage The message associated to the event.

   349     */

   350     void DeleteDomainROL( const RMessage2& aMessage );

   351 

   352     /**

   353     * Return the domain RO for a given content ID.

   354     * @since 3.0

   355     * @params aMessage The message associated to the event.

   356     */

   357     void GetDomainRosForCidL( const RMessage2& aMessage );

   358 

   359     /**

   360     * Check whether the RO is in Replay Cache.

   361     * @since 3.0

   362     * @pareams aMessage The message associated to the event.

   363     */

   364     void IsInCacheL( const RMessage2& aMessage );

   365 

   366     /**

   367     * Add the RO entry to Replay Cache.

   368     * @since 3.0

   369     * @params aMessage The message associated to the event.

   370     */

   371     void AddToCacheL( const RMessage2& aMessage );

   372 

   373     /**

   374     * Delete expired permission if we have secure time.

   375     * @since 3.0

   376     * @params aMessage The message associated to the event.

   377     */

   378     void DeleteExpiredPermissionsL( const RMessage2& aMessage );

   379 

   380     /**

   381     * Sets the estimated arrival for a Content URI

   382     * @since 2.6

   383     * @params aMessage The message associated to the event.

   384     */

   385     void SetEstimatedArrivalL( const RMessage2& aMessage );

   386 

   387     /**

   388     * Gets the estimated arrival for a Content URI

   389     * @since 2.6

   390     * @params aMessage The message associated to the event.

   391     */

   392     void GetEstimatedArrivalL( const RMessage2& aMessage );

   393 

   394     /**

   395     * Gets the udt data

   396     * @since 3.0

   397     * @params aMessage The message associated to the event.

   398     */

   399     void GetUdtDataL( const RMessage2& aMessage );

   400 

   401     /**

   402     * Initiates the UDT

   403     * @since 3.0

   404     * @params aMessage The message associated to the event.

   405     */

   406     void InitiateUdtL( const RMessage2& aMessage );

   407 

   408     /**

   409     * Helper function for ServiceL().

   410     * @since 3.0

   411     * @param aMessage The message associated to the event.

   412     */

   413     void InitExportOrphanedCIDsL( const RMessage2& aMessage );

   414 

   415     /**

   416     * Helper function for ServiceL().

   417     * @since 3.0

   418     * @param aMessage The message associated to the event.

   419     */

   420     void ExportOrphanedCIDsL( const RMessage2& aMessage );

   421 

   422     /**

   423     * Unwrap MAC and REK which are wrapped either with

   424     * device public key or domain key

   425     * @since 3.1

   426     * @param aMessage The message associated to the event.

   427     * @param aDomainRo ETrue if a domain key is used for wrapping

   428     *                  EFalse if device public key is used wrapping

   429     */

   430     void UnwrapMacAndRekL( const RMessage2& aMessage, TBool aDomainRo );

   431 

   432     /**

   433     * This methods converts the given list into a permanent file

   434     * representation.

   435     * @since S60Rel2.5

   436     * @param aList List to be converted into a file.

   437     * @param aFile Output file name.

   438     */

   439     void ListToFileL( RPointerArray< CDRMPermission >& aList,

   440                       TFileName& aFile );

   441 

   442     /**

   443     * Tries to locate the best permission candidates from the given list based

   444     * on the given usage intent.

   445     * @return Index of the best child in aList, >= 0 always. Leaves if no

   446     *         suitable child is found.

   447     */

   448     TInt FindBestROsL( RDRMPermissionList& aList,

   449                        const TDesC8& aURI,

   450                        const ContentAccess::TIntent aIntent,

   451                        HBufC8*& aUsedURI,

   452                        TUint32& aReason );

   453 

   454     /**

   455     * Returns ETrue if might be possible to use the permission

   456     * as a child permission in the first place.

   457     */

   458     TBool IsValidPermissionL( CDRMPermission& aPermission,

   459                               const ContentAccess::TIntent aIntent,

   460                               const TTime& aTime,

   461                               TUint32& aReason );

   462 

   463 

   464     void Normalize( CDRMPermission& aPermission,

   465                     CDRMConstraint& aNormalized,

   466                     const ContentAccess::TIntent aIntent );

   467 

   468     TBool BetterPermission( const CDRMConstraint& aNewOne,

   469                             const CDRMConstraint& aOldOne );

   470 

   471 

   472     TInt GetBestROL( RDRMPermissionList& aList,

   473                      const TIntent aIntent,

   474                      TUint32& aReason );

   475 

   476     /**

   477     * This method checks whether the constraint has expired.

   478     *

   479     * @since S60Rel2.5

   480     * @param aConstraint Rights constraint.

   481     * @return Truth value.

   482     */

   483     inline TBool Expired( const CDRMConstraint& aConstraint );

   484 

   485     /**

   486     * finds the parent permissions and does not add unusable parents and removes unusable childred

   487     *

   488     * @param aList      List of child permissions

   489     * @param aIntent    Intent for use

   490     * @param aDrmTime   Drm time of the device

   491     * @param aReason    Out-parameter: a bitvector of why some prmissions were disqualified

   492     */

   493     void FindParentsAndRemoveUnusableL( RDRMPermissionList& aList,

   494                                         const TDesC8& aURI,

   495                                         CDRMPointerArray<HBufC8>& aCids,

   496                                         const TIntent aIntent,

   497                                         const TTime& aDrmTime,

   498                                         TUint32& aReason );

   499 

   500     /**

   501     * This method checks whether the constraint is invalid

   502     * (count < 1 || interval <= 0 ).

   503     *

   504     * @since S60Rel2.6

   505     * @param aConstraint Rights constraint.

   506     * @return Truth value.

   507     */

   508     inline TBool Invalid( const CDRMConstraint& aConstraint );

   509 

   510     /**

   511     * This method updates the trusted time and its trust level from DRM server.

   512     * Since S60Rel2.5

   513     */

   514     inline void UpdateSecureTime();

   515 

   516     /**

   517     * Unwrap a CEK which is wrapped with a REK

   518     *

   519     * @param aProtectedCek Wrapped CEK

   520     * @return Unwrapped CEK

   521     */

   522     HBufC8* UnwrapProtectedCekL( const TDesC8& aProtectedCek );

   523 

   524     /**

   525     * Unwrap a CEK which is wrapped with a domain key.

   526     *

   527     * @param aProtectedCek Wrapped CEK

   528     * @param aDomainId ID of the domain key

   529     * @return Unwrapped CEK

   530     */

   531     HBufC8* UnwrapDomainCekL( const TDesC8& aProtectedCek,

   532                               const TDesC8& aDomainId );

   533 

   534     /**

   535     * Set the authentication seed for a content ID

   536     *

   537     * @param aMessage IPC message

   538     */

   539     void SetAuthenticationSeedL( const RMessage2& aMessage );

   540 

   541     /**

   542     * Return the authentication seed for a content ID

   543     *

   544     * @param aMessage IPC message

   545     */

   546     void GetAuthenticationSeedL( const RMessage2& aMessage );

   547 

   548     /**

   549     * Integrity protection for protected ROs

   550     *

   551     * @param aMessage IPC message

   552     */

   553     void VerifyMacL( const RMessage2& aMessage );

   554 

   555     /**

   556     *

   557     *

   558     * @param aMessage IPC message

   559     */

   560     void GetSupportedIndividualsL( const RMessage2& aMessage );

   561 

   562     /**

   563     * Stop watching the DCF repository server and the rights DB

   564     *

   565     * @param aMessage IPC message

   566     */

   567     void StopWatchingL( const RMessage2& aMessage );

   568 

   569     /**

   570     * Return the current content ID

   571     *

   572     * @return content ID

   573     */

   574     const TDesC8& GetContentId();

   575 

   576     /**

   577     * Remove permissions which are currently invalid (e.g. domain context

   578     * not available)

   579     *

   580     * @param aList List of permissions

   581     */

   582     void RemoveInvalidPermissionsL( CDRMPermissionList* aList );

   583 

   584     void SetNameL( const RMessage2& aMessage );

   585 

   586     void GetNameL( const RMessage2& aMessage );

   587 

   588     void GetWideDataL( const RMessage2& aMessage );

   589 

   590     void Cancel( const RMessage2& aMessage );

   591 

   592     void GetFLUriL( const RMessage2& aMessage );

   593 

   594     void EncodeRightsIssuerL( const RMessage2& aMessage );

   595 

   596     void DecodeRightsIssuerL( const RMessage2& aMessage );

   597 

   598     void GetRandomDataL( const RMessage2& aMessage );

   599 

   600     void GetFlURI( TDes8& aURI );

   601 

   602     void AesEncryptL( const TDesC8& aKey,

   603                       const TDesC8& aIV,

   604                       const TBool aAddPadding,

   605                       TDes8& aData );

   606 

   607     void AesDecryptL( const TDesC8& aKey,

   608                       const TDesC8& aIV,

   609                       const TBool aRemovePadding,

   610                       TDes8& aData );

   611 

   612     void GenerateIVL( TDes8& aData );

   613 

   614     TBool PendingRights(const TDesC8& aCid, TBool aRemoval = ETrue);

   615 

   616     /**

   617     * This method tries to find a suitable rights object

   618     * from the given list which allows the specified intent.

   619     * @since S60Rel3.0

   620     * @param aIntent Intent.

   621     * @param aURI    Content URI

   622     * @param aChild  Out-parameter: related child permissino. The caller

   623     *                owns the child.

   624     * @param aParent Out-parameter: related parent permission. The caller

   625     *                owns the parent.

   626     * @param aReason A bitvector of reasons for rights object rejection

   627     */

   628     void FindRightsObjectL( const ContentAccess::TIntent aIntent,

   629                             const TDesC8& aURI,

   630                             CDRMPermission*& aChild,

   631                             HBufC8*& aUsedURI,

   632                             TUint32& aReason );

   633 

   634     /**

   635     * Check if the deletion of the mentioned content id is allowed:

   636     */

   637     TBool DeleteAllowedL( const TDesC8& aContentId );

   638 

   639     // Prohibit copy constructor.

   640     CDRMDbSession( const CDRMDbSession& );

   641     // Prohibit assigment operator.

   642     CDRMDbSession& operator=( const CDRMDbSession& );

   643 

   644     void GetMeteringDataL( const RMessage2& aMessage );

   645 

   646     void DeleteMeteringDataL( const RMessage2& aMessage );

   647 

   648 public:     // Data

   649 

   650 protected:  // Data

   651 

   652 private:    // Data

   653 

   654     TTime iTrustedTime;

   655     TBool iSecureTime;

   656     HBufC8* iPreparedData;

   657     HBufC* iWidePreparedData;

   658     CActive* iPendingRequest;

   659     CDRMConsume* iConsume;

   660 

   661     // Decryption key for this session

   662     TBuf8< KDRMKeyLength > iCek;

   663 

   664     // Rights encyrption key for this session, used for adding protected keys and

   665     // the authentication seed

   666     TBuf8< KDRMKeyLength > iRek;

   667 

   668     TBuf8< KDRMKeyLength > iMac;

   669 

   670     // Have the credentials of the caller been checked for this session?

   671     TCredentialsCheckType iCredentialsChecked;

   672 

   673     // Filename used for getting obsolete Contents

   674     TFileName* iFileName;

   675 

   676     // Client handle

   677     RThread iClient;

   678 

   679     // ID of the currently handled content

   680     HBufC8* iContentId;

   681 

   682     // Roap client

   683     TBool iRoapClientConnected;

   684     Roap::RRoapStorageClient iRoapClient;

   685 

   686 public:     // Friend classes

   687 protected:  // Friend classes

   688 private:    // Friend classes

   689     };

   690 

   691 #include "DRMDbSession.inl"

   692 

   693 

   694 #endif      // CDRMDBSESSION_H

   695 

   696 // End of File