/*

* Copyright (c) 2004-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Session class for handling roap storage client requests

*

*/

// INCLUDE FILES

#include <s32file.h>

#include <f32file.h>

#include <x509cert.h>

#include <x509keys.h>

#include <asn1dec.h>

#include <hash.h>

#include <s32mem.h>

#include <centralrepository.h>

#include <uri8.h>

#ifdef RD_DRM_METERING

#include <DRMRightsClient.h>

#include <random.h>

#endif //RD_DRM_METERING

#ifdef RD_MULTIPLE_DRIVE

#endif

#include <e32base.h>  // CleanupResetAndDestroyPushL dependencies

#include "drmaescrypto.h"

#include "RoapStorageSession.h"

#include "DRMContextDB.h"

#include "DRMRIContext.h"

#include "DRMDomainContext.h"

#include "RoapStorageServer.h"

#include "CmlaCrypto.h"

#include "DrmKeyStorage.h"

#include "RoapDef.h"

#include "RoapLog.h"

#include "drmroapclientserver.h"

//OCSP classes

#include "responsedecoder.h"

#include "certid.h"

//drm clock

#include "cleanupresetanddestroy.h" // CleanupResetAndDestroyPushL

// NAMESPACES

using namespace Roap;

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KMaxElementLength = 327680;

const TInt KMinDomainIdLength = 4;

// DEBUG PRINT MACROS

#ifdef _DEBUG

#include <flogger.h>

_LIT(KMacLogDir, "DRM");

_LIT(KMacLogFile, "MAC.log");

#define MACLOG( a ) RFileLogger::Write( KMacLogDir(), KMacLogFile(), EFileLoggingModeAppend, a );

#define MACLOGHEX( ptr, len ) RFileLogger::HexDump( KMacLogDir(), KMacLogFile(), EFileLoggingModeAppend, _S(""), _S(""), ptr, len );

#define MACLOGLIT( a ) MACLOG( _L ( a ) )

#define _DRM_DETAILED_DEBUG // uncomment if want detailed debugs to log file

#else

#undef _DRM_DETAILED_DEBUG

#define MACLOG( a )

#define MACLOGHEX( ptr, len )

#define MACLOGLIT( a )

#endif

#ifdef _DRM_DETAILED_DEBUG

#define MACLOGDETAIL( a ) MACLOG( a )

#define MACLOGHEXDETAIL( ptr, len ) MACLOGHEX( ptr, len )

#define MACLOGLITDETAIL( a ) MACLOGLIT( a )

#define MACLOGLDETAIL( a ) MACLOGLIT( a )

#define CERTDETAIL( c ) \

{ \

const TPtrC8* n( c->DataElementEncoding( CX509Certificate::ESerialNumber ) ); \

const TPtrC8* a( c->DataElementEncoding( CX509Certificate::EAlgorithmId ) ); \

const TPtrC8* s( c->DataElementEncoding( CX509Certificate::ESubjectName ) ); \

const TPtrC8* i( c->DataElementEncoding( CX509Certificate::EIssuerName ) ); \

const TPtrC8* p( c->DataElementEncoding( CX509Certificate::ESubjectPublicKeyInfo ) ); \

MACLOGLDETAIL( "certificate (subject issuer serial algorithm key)" ) \

MACLOGHEXDETAIL( s->Ptr(), s->Length() ) \

MACLOGHEXDETAIL( i->Ptr(), i->Length() ) \

MACLOGHEXDETAIL( n->Ptr(), n->Length() ) \

MACLOGHEXDETAIL( a->Ptr(), a->Length() ) \

MACLOGHEXDETAIL( p->Ptr(), p->Length() ) \

}

#else

#define MACLOGDETAIL( a )

#define MACLOGHEXDETAIL( ptr, len )

#define MACLOGLITDETAIL( a )

#define MACLOGLDETAIL( a )

#define CERTDETAIL( a )

#endif

// END OF DEBUG PRINT MACROS

// LOCAL CONSTANTS AND MACROS

_LIT8( KRoapDomainKey, "roap:domainKey");

_LIT8( KRoapX509SPKIHash, "roap:X509SPKIHash");

_LIT8( KRoapXmlNs, " xmlns:roap=\"urn:oma:bac:dldrm:roap-1.0\"");

#ifdef RD_DRM_METERING

_LIT8( KCmlaIp1, "http://www.cm-la.com/tech/cmlaip/cmlaip#cmlaip-1");

#endif

static const TUid KCRUidRoapHandler =

    {

    0x10205CBF

    };

static const TInt KRoapHandlerRegistrationWhitelist = 1;

static const TInt KMaxWhiteListLen = 1024;

static const TInt KTzZulu( 0 ); //UTC time zone

#ifdef RD_MULTIPLE_DRIVE

_LIT( KRIContextFileName, "_:\\private\\101F51F2\\ricontexts.dat" );

_LIT( KDomainContextFileName, "_:\\private\\101F51F2\\domaincontexts.dat" );

#endif

#define ROAPDB ( ( CRoapStorageServer* )( Server() ) )->ContextDB()

static const TInt KP3( 3 );

#define IPCREAD0L( a ) aMessage.ReadL( 0, a )

#define IPCREAD1L( a ) aMessage.ReadL( 1, a )

#define IPCREAD2L( a ) aMessage.ReadL( 2, a )

#define IPCREAD3L( a ) aMessage.ReadL( KP3, a )

#define IPCWRITE0L( a ) aMessage.WriteL( 0, a )

#define IPCWRITE1L( a ) aMessage.WriteL( 1, a )

#define IPCWRITE2L( a ) aMessage.WriteL( 2, a )

#define IPCWRITE3L( a ) aMessage.WriteL( KP3, a )

#define IPCGETDESLEN0 aMessage.GetDesLength( 0 )

#define IPCGETDESLEN1 aMessage.GetDesLength( 1 )

#define IPCGETDESLEN2 aMessage.GetDesLength( 2 )

#define IPCGETDESLEN3 aMessage.GetDesLength( KP3 )

#define IPCGETDESMAXLEN0 aMessage.GetDesMaxLength( 0 )

#define IPCGETDESMAXLEN1 aMessage.GetDesMaxLength( 1 )

#define IPCGETDESMAXLEN2 aMessage.GetDesMaxLength( 2 )

#define IPCGETDESMAXLEN3 aMessage.GetDesMaxLength( KP3 )

const TInt KSanityDataLengthLow = 0;

const TInt KSanityDataLengthHigh = 32768;

// DATA TYPES

// LOCAL FUNCTION PROTOTYPES

LOCAL_C RPointerArray<HBufC8> BufferToArrayL( TDesC8& aBuffer );

LOCAL_C HBufC8* ArrayToBufferLC( const RPointerArray<HBufC8>& aArray );

LOCAL_C void UnwrapDomainKeyL( MDrmKeyStorage* aKeyStorage,

    const TDesC8& aProtectedDomainKey, HBufC8*& aDomainKey, HBufC8*& aMacKey,

    TKeyTransportScheme& aTransportScheme );

LOCAL_C TBool VerifyMacL( TDesC8& aDomainElements, TDesC8& aMacs,

    RPointerArray<HBufC8>& aMacKeys );

// ---------------------------------------------------------------------------

// DeleteAndSetNull

// ---------------------------------------------------------------------------

//

template<typename Taa> Taa*& DeleteAndSetNull( Taa*& aArg )

    {

    if ( aArg )

        {

        delete aArg;

        aArg = NULL;

        }

    return aArg;

    }

// ---------------------------------------------------------------------------

// SanitizeL

// Performs a sanity check on length parameters

// ---------------------------------------------------------------------------

//

LOCAL_C void SanitizeL( TInt aParam )

    {

    User::LeaveIfError( aParam );

    if ( aParam <= KSanityDataLengthLow || aParam > KSanityDataLengthHigh )

        {

        User::Leave( KErrArgument );

        }

    }

// ---------------------------------------------------------------------------

// Swap elements

// ---------------------------------------------------------------------------

//

template<typename T>

LOCAL_C void SwapElement( RPointerArray<T>& aArray, TInt aFirst, TInt aSecond )

    {

    if ( aFirst != aSecond )

        {

        T* temp( NULL);

        temp = aArray[aFirst];

        aArray[aFirst] = aArray[aSecond];

        aArray[aSecond] = temp;

        }

    }

// ---------------------------------------------------------------------------

// Sort Ocsp responses for certChain validation

// ---------------------------------------------------------------------------

//

LOCAL_C TBool SortOcspCertsL( RPointerArray<CX509Certificate>& aOcspCerts,

    const CX509Certificate* aRootCert )

    {

    MACLOGLITDETAIL( "::SortOcspCertsL -->" )

    const TInt last( aOcspCerts.Count() - 1 );

    TBool sortable( EFalse );

    // Find first find cert issued by root cert

    // There can be only one cert issued by Root on valid cert chain

    for ( TInt i( 0 ); !sortable && i <= last; i++ )

        {

        if ( aRootCert->SubjectName().ExactMatchL(

            aOcspCerts[i]->IssuerName() ) )

            {

            SwapElement<CX509Certificate> ( aOcspCerts, i, last );

            sortable = ETrue;

            }

        }

    for ( TInt s(last); sortable && s > 0; s-- )

        {

        sortable = EFalse;

        for ( TInt i( s - 1 ); !sortable && i >= 0; i-- )

            {

            // compare cert s subject to issuer i

            if ( aOcspCerts[s]->SubjectName().ExactMatchL(

                aOcspCerts[i]->IssuerName() ) )

                {

                SwapElement<CX509Certificate> ( aOcspCerts, i, s-1 );

                sortable = ETrue;

                }

            }

        }

    MACLOGLITDETAIL( "--> ::SortOcspCertsL" )

    return sortable;

    }

// ---------------------------------------------------------------------------

// VerifyOcspCertChainL()

// ---------------------------------------------------------------------------

//

LOCAL_C TBool VerifyOcspCertChainL( const COCSPResponse& aResponse,

    const CX509Certificate* aRootCert, CX509Certificate*& aOcspCert )

    {

    MACLOGLITDETAIL( "::VerifyOcspCertChainL -->" )

    CX509Certificate* cert = NULL;

    const CX509Certificate* signingCert = NULL;

    TInt pos = 0;

    TBool result = ETrue;

    RPointerArray<CX509Certificate> certArray;

    CleanupResetAndDestroyPushL( certArray );

    const TPtrC8* ocspCerts( aResponse.SigningCerts() );

    if ( !ocspCerts )

        {

        MACLOGLIT( "No OCSP certs present" )

#ifdef _DISABLE_OCSP_CHECK

        CleanupStack::PopAndDestroy( &certArray );

        return ETrue;

#endif

        User::Leave( KErrRoapServerFatal );

        }

    MACLOGLITDETAIL( "getting certs in OCSP response" )

    while ( pos < ocspCerts->Length() )

        {

        cert = CX509Certificate::NewLC( *ocspCerts, pos );

        certArray.AppendL( cert );

        CleanupStack::Pop( cert );

        CERTDETAIL( cert )

        }

    result = SortOcspCertsL( certArray, aRootCert );

    // validate the OCSP cert chain up till root cert (root cert is already validated)

    for ( TInt i = 0; i < certArray.Count() && result; i++ )

        {

        cert = certArray[i];

        if ( certArray.Count() - 1 == i )

            {

            signingCert = aRootCert;

            }

        else

            {

            signingCert = certArray[i + 1];

            }

        MACLOGLDETAIL( "OCSP verify, using certificate" )

        CERTDETAIL( cert )

        result = cert->VerifySignatureL( signingCert->PublicKey().KeyData() );

#ifdef _DEBUG

        if ( result )

            {

            MACLOGLIT( "Verify succeeded." )

            }

        else

            {

            MACLOGLIT( "Verify failed." )

            }

#endif

        }

    // Copy OCSP cert and return it

    aOcspCert = CX509Certificate::NewL( *certArray[0] );

    CleanupStack::PopAndDestroy( &certArray );

    MACLOGLITDETAIL( "--> ::VerifyOcspCertChainL" )

    return result;

    }

#ifdef _DISABLE_DRM_TIME_UPDATE_CHECK

LOCAL_C TBool IsCmlaRootL(

    const RPointerArray<HBufC8>& /*aTrustedRoots*/,

    const CX509Certificate* /* aRootCert */)

    {

    MACLOGLITDETAIL( "IsCmlaRootL -->\n--> IsCmlaRootL" )

    return ETrue;

    }

#else

LOCAL_C TBool IsCmlaRootL( const RPointerArray<HBufC8>& aTrustedRoots,

    const CX509Certificate* aRootCert )

    {

    MACLOGLITDETAIL( "IsCmlaRootL -->" )

    TBool isCmlaRoot( EFalse );

    // Check are we running on a CMLA device

    for ( TInt i = 0; i < aTrustedRoots.Count() && !isCmlaRoot; i++ )

        {

        HBufC8* encodedRoot( Base64EncodeL( *aTrustedRoots[i] ) );

        CleanupStack::PushL( encodedRoot );

        if ( encodedRoot->CompareF( KRoapCmlaRootHash() ) == 0

            || encodedRoot->CompareF( KRoapCmlaRnDRootHash() ) == 0

            || encodedRoot->CompareF( KRoapCmlaRnDRootHashOld() ) == 0 )

            {

            isCmlaRoot = ETrue;

            }

        CleanupStack::PopAndDestroy( encodedRoot );

        encodedRoot = NULL;

        }

    if ( isCmlaRoot )

        {

        __UHEAP_MARK;

        // The root cert found, check that it's the CMLA (production or R&D) root

        CSHA1* hash( CSHA1::NewL() );

        CleanupStack::PushL( hash );

        hash->Hash( *aRootCert->DataElementEncoding(

            CX509Certificate::ESubjectPublicKeyInfo ) );

        MACLOGLDETAIL( "Inputs for SHA1" )

        MACLOGHEXDETAIL(

            aRootCert->DataElementEncoding(

                CX509Certificate::ESubjectPublicKeyInfo )->Ptr(),

            aRootCert->DataElementEncoding(

                CX509Certificate::ESubjectPublicKeyInfo )->Length() )

        HBufC8* encodedRoot( Base64EncodeL( hash->Final() ) );

        CleanupStack::PushL( encodedRoot );

        MACLOGLDETAIL( "Encoded root (base64 encoded SHA1 of public key)" )

        MACLOGDETAIL( *encodedRoot )

        MACLOGLDETAIL( "CMLA root" )

        MACLOGDETAIL( KRoapCmlaRootHash() )

        MACLOGLDETAIL( "CMLA RD root" )

        MACLOGDETAIL( KRoapCmlaRnDRootHash() )

        MACLOGLDETAIL( "old CMLA RD root" )

        MACLOGDETAIL( KRoapCmlaRnDRootHashOld() )

        if ( encodedRoot->CompareF( KRoapCmlaRootHash() ) != 0

            && encodedRoot->CompareF( KRoapCmlaRnDRootHash() ) != 0

            && encodedRoot->CompareF( KRoapCmlaRnDRootHashOld() ) != 0 )

            {

            // The RI CA cert is not signed by CMLA root

            MACLOGLIT( "The RI CA cert is not signed by CMLA (production or R&D) root" )

            isCmlaRoot = EFalse;

            }

        else

            {

            // We are running on a CMLA device and

            // RI certificate is signed by the CMLA (production or R&D) root

            // -> Verify still that the OCSP chain is signed by CMLA

            MACLOGLIT( "RI certificate is signed by the CMLA root" )

            }

        CleanupStack::PopAndDestroy( encodedRoot );

        CleanupStack::PopAndDestroy( hash );

        __UHEAP_MARKEND;

        }

    MACLOGLITDETAIL( "--> IsCmlaRootL" )

    return isCmlaRoot;

    }

#endif

// ---------------------------------------------------------------------------

// ValidateNonceL

// ---------------------------------------------------------------------------

//

LOCAL_C TBool ValidateNonceL( const COCSPResponse& aResponse,

    const TDesC8& aRegReqNonce )

    {

    // check that nonce in OCSP response equals to the nonce sent in Reg Request

    TBool ret( EFalse );

    const TPtrC8 * nonce( aResponse.DataElementEncoding(

        COCSPResponse::ENonce ) );

    if ( !nonce )

        {

        // no nonce found -> don't update DRM Time

        MACLOGLIT( "No nonce in the OCSP response!" )

        ret = EFalse;

        }

    else if ( nonce->CompareF( aRegReqNonce ) != 0 )

        {

        // Maybe the nonce is in ASN.1 format?

        // -> Remove the first two bytes (type and size), and try again

        TASN1DecGeneric asn1Dec( *nonce );

        asn1Dec.InitL();

        TPtrC8 ptr( asn1Dec.GetContentDER() );

        if ( ptr.CompareF( aRegReqNonce ) != 0 )

            {

            MACLOGLIT( "Fatal server error: OCSP nonce != RegRequest nonce!" )

            User::Leave( KErrRoapServerFatal );

            }

        else

            {

            MACLOGLIT( "OCSP nonce == RegRequest nonce." )

            ret = ETrue;

            }

        MACLOGLDETAIL( "values ( OCSP nonce, request nonce  )" )

        MACLOGHEXDETAIL( nonce->Ptr(), nonce->Length() )

        MACLOGHEXDETAIL( aRegReqNonce.Ptr(), aRegReqNonce.Length() )

        }

    else

        {

        ret = ETrue;

        MACLOGLDETAIL( "values ( OCSP nonce, request nonce  )" )

        MACLOGHEXDETAIL( nonce->Ptr(), nonce->Length() )

        MACLOGHEXDETAIL( aRegReqNonce.Ptr(), aRegReqNonce.Length() )

        }

    return ret;

    }

// ---------------------------------------------------------------------------

// IsTimeUpdateAllowedL()

// ---------------------------------------------------------------------------

//

LOCAL_C TBool IsTimeUpdateAllowedL(

    const RPointerArray<HBufC8>& aTrustedRoots,

    const RPointerArray<HBufC8>& aRootCertificates,

    const RPointerArray<HBufC8>& aCertChain,

    const COCSPResponse& aOcspResponse,

    const TDesC8& aRegReqNonce )

    {

    MACLOGLITDETAIL( "::IsTimeUpdateAllowedL -->" )

    // check that nonce in OCSP response equals to the nonce sent in Reg Request

    TBool bIsAllowed( ValidateNonceL( aOcspResponse, aRegReqNonce ) );

    if ( !bIsAllowed )

        {

        MACLOGLIT( "No nonce. Not possible to update DRM time" )

        return bIsAllowed;

        }

    if ( !aCertChain.Count() )

        {

        MACLOGLIT( "Wrong input data - No certificates or OCSP responses" )

        bIsAllowed = EFalse;

        return bIsAllowed;

        }

    CX509Certificate* riCa = NULL;

    CX509Certificate* rootCert = NULL;

    // Get the last cert from the chain.

    // It should be signed by some of our trusted anchor

    riCa = CX509Certificate::NewLC( *( aCertChain[aCertChain.Count() - 1] ) );

    MACLOGLITDETAIL( "Selected as RI CA" ) // (last of given cert chain)

    CERTDETAIL( riCa )

    // iterate over root certificates and check, whether given

    // RI CA issuer matches name of the selected root

    for ( TInt i = 0; i < aRootCertificates.Count() && !rootCert; i++ )

        {

        rootCert = CX509Certificate::NewL( *aRootCertificates[i] );

        if ( !rootCert->SubjectName().ExactMatchL( riCa->IssuerName() ) )

            {

            delete rootCert;

            rootCert = NULL;

            }

        }

    if ( rootCert )

        {

        MACLOGLDETAIL( "Selected root CERT" )

        CERTDETAIL( rootCert )

        CleanupStack::PushL( rootCert );

        if ( IsCmlaRootL( aTrustedRoots, rootCert ) )

            {

            CX509Certificate* ocspCert = NULL;

            __UHEAP_MARK;

            // Try to verify OCSP cert chain with the root cert

            if ( VerifyOcspCertChainL( aOcspResponse, rootCert,

                DeleteAndSetNull<CX509Certificate> ( ocspCert ) ) )

                {

                MACLOGLITDETAIL( "OCSP cert chain verified with root cert" )

                MACLOGLIT( "DRM Time update allowed!" )

                bIsAllowed = ETrue;

                }

            // Try to verify OCSP cert chain with the RI CA cert