/*

* Copyright (c) 2002-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:  Class representing metering report request

*

*/

// INCLUDE FILES

#include <e32std.h>

#include "Base64.h"

#include "MeteringReportReq.h"

#include "RoapLog.h"

using namespace Roap;

// LOCAL CONSTANTS AND MACROS

// XML tag related literals

// Warning: these literals are very fragile in respect to XML canonicalisation.

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

_LIT8(KReqNonceTrigger, " triggerNonce=\"");

_LIT8(KReqNonceTriggerEnd, "\"");

_LIT8(KReqHeaderEnd, ">");

_LIT8(KReqDeviceId, "<deviceID><keyIdentifier xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"roap:X509SPKIHash\"><hash>");

_LIT8(KReqDeviceIdEnd, "</hash></keyIdentifier></deviceID>");

_LIT8(KReqRiId, "<riID><keyIdentifier xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"roap:X509SPKIHash\"><hash>");

_LIT8(KReqRiIdEnd, "</hash></keyIdentifier></riID>");

_LIT8(KReqNonce, "<nonce>");

_LIT8(KReqNonceEnd, "</nonce>");

_LIT8(KReqTime, "<time>");

_LIT8(KReqTimeEnd, "</time>");

_LIT8(KReqMeteringReport, "<meteringReport>");

_LIT8(KReqReportHeader,

"<encryptedMeteringReport>\

<xenc:EncryptedData xmlns:xenc=\"http://www.w3.org/2001/04/xmlenc#\"\

 Type=\"http://www.w3.org/2001/04/xmlenc#Content\">\

<xenc:EncryptionMethod\

 Algorithm=\"http://www.w3.org/2001/04/xmlenc#aes128-cbc\">\

</xenc:EncryptionMethod>");

_LIT8(KReqKeyInfo, "<ds:KeyInfo xmlns:ds=\"http://www.w3.org/2000/09/xmldsig#\">\

<ds:RetrievalMethod URI=\"#K_MEK_and_K_MAC\"></ds:RetrievalMethod>\

</ds:KeyInfo>");

_LIT8(KReqCipherDataStart, "<xenc:CipherData><xenc:CipherValue>");

_LIT8(KReqCipherDataEnd, "</xenc:CipherValue></xenc:CipherData></xenc:EncryptedData></encryptedMeteringReport>");

_LIT8(KReqEncKeyAndMethod, "<encKey Id=\"K_MEK_and_K_MAC\"><xenc:EncryptionMethod\

 xmlns:xenc=\"http://www.w3.org/2001/04/xmlenc#\" Algorithm=\"" );

_LIT8(KReqEncKeyAndMethodAfterAlgorithm, "\"></xenc:EncryptionMethod>");

_LIT8(KReqEncKeyInfoStart, "<ds:KeyInfo xmlns:ds=\"http://www.w3.org/2000/09/xmldsig#\">");

// Note the two versions below are because of different namespace

// normalisation of element roap:X509SPKIHash on canonicalisation of

// whole request to be signed and on canonicalisation of element

// <meteringReport> to be MAC calculated.

// when changing one of these another one must be cahnges too.

//

// This version is used when canonicalisation is performed over

// <roap:meteringReportSubmit>

//

_LIT8(KReqRoapX509AndHash, "<roap:X509SPKIHash><hash>");

//

//

// This version is used when canonicalisation is taken over <meteringReport>

// (on MAC calculation)

//

_LIT8(KReqRoapX509AndHashNs, "<roap:X509SPKIHash xmlns:roap=\"urn:oma:bac:dldrm:roap-1.0\"><hash>");

_LIT8(KReqEncKeyInfoEnd, "</hash></roap:X509SPKIHash></ds:KeyInfo>\

<xenc:CipherData xmlns:xenc=\"http://www.w3.org/2001/04/xmlenc#\"><xenc:CipherValue>");

_LIT8(KReqCipherValueEnd, "</xenc:CipherValue></xenc:CipherData></encKey>");

_LIT8(KReqMacStart, "<mac>");

_LIT8(KReqMacEnd, "</mac>");

_LIT8(KReqReportHeaderEnd, "</meteringReport>");

_LIT8(KReqCertChain, "<certificateChain>");

_LIT8(KReqCert, "<certificate>");

_LIT8(KReqCertEnd, "</certificate>");

_LIT8(KReqCertChainEnd, "</certificateChain>");

_LIT8(KReqSig, "<signature>");

_LIT8(KReqSigEnd, "</signature></roap:meteringReportSubmit>");

// literals for key transport scheme

_LIT8( KOmaKdf, "http://www.rsasecurity.com/rsalabs/pkcs/schemas/pkcs-1#rsaes-kem-kdf2-kw-aes128");

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

// ============================ LOCAL FUNCTIONS ===============================

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

// MeteringReportElementAsTextL

//

// write content of to given flat buffer

// Used from MessageAsXmlL and from InsertMacL

// Note content depends on value of

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

LOCAL_C inline void MeteringReportElementAsTextL(

    CBufFlat*& aBuf,

    const Roap::CMeteringReportReq& aReq

    )

    {

    Roap::CRoapMessage::BufAppendL( aBuf, KReqMeteringReport );

    Roap::CRoapMessage::BufAppendL( aBuf, KReqReportHeader );

    Roap::CRoapMessage::BufAppendL( aBuf, KReqKeyInfo );

    Roap::CRoapMessage::BufAppendL( aBuf, KReqCipherDataStart );

    // actual encrypted metering data

    if ( aReq.iCipherValue )

        {

        Roap::CRoapMessage::BufAppendBase64L( aBuf, *aReq.iCipherValue );

        }

    Roap::CRoapMessage::BufAppendL( aBuf, KReqCipherDataEnd );

    Roap::CRoapMessage::BufAppendL( aBuf, KReqEncKeyAndMethod );

    // Select KDF algorithm in use

    if ( aReq.iAlgorithmInUse == ECmlaIp1 )

        {

        Roap::CRoapMessage::BufAppendL( aBuf, KCmlaIp1 );

        }

    else if ( aReq.iAlgorithmInUse == EOma )

        {

        Roap::CRoapMessage::BufAppendL( aBuf, KOmaKdf );

        }

    else

        {

        User::Leave( KErrNotSupported );

        }

    Roap::CRoapMessage::BufAppendL( aBuf, KReqEncKeyAndMethodAfterAlgorithm );

    Roap::CRoapMessage::BufAppendL( aBuf, KReqEncKeyInfoStart );

    if ( aReq.iMac )

        {

        // used as part of roap:Meteringreport submit

        // so namespace ROAP already defined in container element

        Roap::CRoapMessage::BufAppendL( aBuf, KReqRoapX509AndHash );

        }

    else

        {

        // used in mac calculation

        // canonical form requires namespace definition for namespace roap

        Roap::CRoapMessage::BufAppendL( aBuf, KReqRoapX509AndHashNs );

        }

    // Insert 128-bit encrypted encryption key PKI hash

    Roap::CRoapMessage::BufAppendBase64L( aBuf, aReq.iEncKeyHash );

    Roap::CRoapMessage::BufAppendL( aBuf, KReqEncKeyInfoEnd );

    // key wrapping info

    Roap::CRoapMessage::BufAppendBase64L( aBuf, *aReq.iEncryptedMekAndMak );

    Roap::CRoapMessage::BufAppendL( aBuf, KReqCipherValueEnd );

    // Insert 128-bit encrypted MAC value

    if ( aReq.iMac )

        {

        Roap::CRoapMessage::BufAppendL( aBuf, KReqMacStart );

        Roap::CRoapMessage::BufAppendBase64L( aBuf, *aReq.iMac );

        Roap::CRoapMessage::BufAppendL( aBuf, KReqMacEnd );

        }

    Roap::CRoapMessage::BufAppendL( aBuf, KReqReportHeaderEnd );

    }

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

// CalculateMacL

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

//

LOCAL_C HBufC8* CalculateMacL(const TDesC8& aElement, const TDesC8& aMacKey )

    {

    LOG( _L8( "CalculateMacL" ) );

    LOG( _L8( "aMacKey" ) );

    LOGHEX( aMacKey.Ptr(), aMacKey.Length() );

    LOG( _L8( "aElement" ) );

    LOGHEX( aElement.Ptr(), aElement.Length() );

    if( !aMacKey.Length() || !aElement.Length() )

        {

        User::Leave(KErrArgument);

        }

    CHMAC* hMac = NULL;

    CSHA1* sha = NULL;

    TPtrC8 hmac_value( KNullDesC8 );

    TPtrC8 sha1_value( KNullDesC8 );

    HBufC8* macValue = NULL;

    sha = CSHA1::NewL();

    CleanupStack::PushL( sha );

    hMac = CHMAC::NewL( aMacKey, sha );

    CleanupStack::Pop( sha ); // sha is now owned by hMac

    CleanupStack::PushL( hMac );

    hMac->Update( aElement );

    hmac_value.Set( hMac->Final() );

    macValue = hmac_value.AllocL();

    LOG( _L8( "macValue" ) );

    LOGHEX( macValue->Ptr(), macValue->Length() );

    CleanupStack::PopAndDestroy( hMac );

    return macValue;

    }

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

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

// CRightsReq::CRightsReq

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMeteringReportReq::CMeteringReportReq():

    iNonce(NULL),

    iReportNonce(NULL),

    iSignature(NULL),

    iCipherValue(NULL),

    iMac(NULL),

    iTriggerNonce(NULL)

    {

    }

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

// CRightsReq::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMeteringReportReq::ConstructL()

    {

    iTime.UniversalTime();

    }

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

// CRightsReq::NewL

// Two-phased constructor.

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

//

CMeteringReportReq* CMeteringReportReq::NewL()

    {

    CMeteringReportReq* self = new( ELeave ) CMeteringReportReq;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CMeteringReportReq::~CMeteringReportReq()

    {

    if ( iCertificateChain.Count() )

        {

        iCertificateChain.ResetAndDestroy();

        }

    delete iSignature;

    delete iTriggerNonce;

    delete iCipherValue;

    delete iEncryptedMekAndMak;

    delete iMac;

    }

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

// CRightsReq::MessageAsXmlL

// Gives XML representation of meteringreport request

// (other items were commented in a header).

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

//

HBufC8* CMeteringReportReq::MessageAsXmlL(void)

    {

    HBufC8* r( NULL );

    CBufFlat* b( CBufFlat::NewL( 128 ) );

    CleanupStack::PushL( b );

    b->InsertL( 0, KReqHeader );

    if ( iTriggerNonce )

        {

        BufAppendL( b, KReqNonceTrigger );

        BufAppendL( b, *iTriggerNonce );

        BufAppendL( b, KReqNonceTriggerEnd );

        }

    BufAppendL( b, KReqHeaderEnd );

    BufAppendL( b, KReqDeviceId );

    BufAppendBase64L( b, iDeviceId );

    BufAppendL( b, KReqDeviceIdEnd );

    BufAppendL( b, KReqRiId );

    BufAppendBase64L( b, iRiId );

    BufAppendL( b, KReqRiIdEnd );

    BufAppendL( b, KReqNonce );

    BufAppendBase64L( b, iNonce );

    BufAppendL( b, KReqNonceEnd );

    BufAppendL( b, KReqTime );

    BufAppendTimeL( b, iTime );

    BufAppendL( b, KReqTimeEnd );

    MeteringReportElementAsTextL( b, *this );

    if ( iCertificateChain.Count() > 0 )

        {

        BufAppendL( b, KReqCertChain );

        for ( TInt i( 0 ); i < iCertificateChain.Count(); i++ )

            {

            BufAppendL( b, KReqCert );

            BufAppendBase64L( b, *iCertificateChain[ i ] );

            BufAppendL( b, KReqCertEnd );

            }

        BufAppendL( b, KReqCertChainEnd );

        }

    BufAppendL(b, KReqSig);

    BufAppendL(b, KReqSigEnd);

    r = b->Ptr( 0 ).AllocL();

    CleanupStack::PopAndDestroy( b );

    return r;

    }

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

// CMeteringReportReq::InsertMacL( const TDesC8& aMac )

// Calculate MAC -value over <encryptedMeteringReport>

// (other items were commented in a header).

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

//

void CMeteringReportReq::InsertMacL( const TDesC8& aMacKey )

    {

    CBufFlat* b( CBufFlat::NewL( 128 ) );

    CleanupStack::PushL( b );

    MeteringReportElementAsTextL( b, *this );

    // Calculate MAC -value over <encryptedMeteringReport>

    // without the actual <mac> -element

    iMac = CalculateMacL( b->Ptr( 0 ), aMacKey );

    CleanupStack::PopAndDestroy( b );

    return;

    }

//  End of File