/*

* Copyright (c) 2002-2004 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:  ?Description

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <f32file.h>

#include <s32file.h>

#include <x509cert.h>

#include <x509keys.h>

#include <asn1dec.h>

#include <hash.h>

#ifdef RD_MULTIPLE_DRIVE

#include <DriveInfo.h>

#endif

#include "OmaCrypto.h"

#include "RoapStorageClient.h"

using namespace Roap;

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

#ifdef RD_MULTIPLE_DRIVE

_LIT(KCertChainDir, "%c:\\drm\\PKI\\");

_LIT(KSigningCertPrefix, "SigningCert");

_LIT(KDeviceCertFileName, "%c:\\drm\\PKI\\DeviceCert.der");

_LIT(KDevicePrivateKeyFileName, "%c:\\drm\\PKI\\DevicePrivateKey.der");

#else

_LIT(KCertChainDir, "c:\\drm\\PKI\\");

_LIT(KSigningCertPrefix, "SigningCert");

_LIT(KDeviceCertFileName, "c:\\drm\\PKI\\DeviceCert.der");

_LIT(KDevicePrivateKeyFileName, "c:\\drm\\PKI\\DevicePrivateKey.der");

#endif

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

LOCAL_C void ReadFileL(

    HBufC8*& aContent,

    const TDesC& aName);

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

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

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

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

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

//

LOCAL_C void ReadFileL(

    HBufC8*& aContent,

    const TDesC& aName)

	{	

	TInt size = 0;

	RFile file;

	RFs fs;

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

	User::LeaveIfError(file.Open(fs, aName, EFileRead));

    CleanupClosePushL(file);

    User::LeaveIfError(file.Size(size));

    aContent = HBufC8::NewLC(size);

    TPtr8 ptr(aContent->Des());

    User::LeaveIfError(file.Read(ptr, size));

	CleanupStack::Pop(); //aContent

	CleanupStack::PopAndDestroy(2); // file, fs

	}

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

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

// RoapStorageClient::RoapStorageClient

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

// might leave.

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

//

RRoapStorageClient::RRoapStorageClient()

    {

    }

// Destructor

RRoapStorageClient::~RRoapStorageClient()

    {

    }

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

// RoapStorageClient::?member_function

// ?implementation_description

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

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

//

TInt RRoapStorageClient::Connect(void)

    {

    return KErrNone;

    }

TInt RRoapStorageClient::GetDeviceCertificateL(

    HBufC8*& aCert)

    {

#ifndef RD_MULTIPLE_DRIVE

    ReadFileL(aCert, KDeviceCertFileName);

#else //RD_MULTIPLE_DRIVE

    RFs fs;

    TInt driveNumber( -1 );

    TChar driveLetter;

    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );

	User::LeaveIfError( fs.Connect() );

	fs.DriveToChar( driveNumber, driveLetter );

    fs.Close();

	TFileName deviceCertFileName;

	deviceCertFileName.Format( KDeviceCertFileName, (TUint)driveLetter );

    ReadFileL(aCert, deviceCertFileName);

#endif

    return KErrNone;

    }

TInt RRoapStorageClient::GetDevicePublicKeyL(

    CRSAPublicKey*& aPublicKey)

    {

    HBufC8* certData;

    CX509Certificate* cert;

    TX509KeyFactory factory;

#ifndef RD_MULTIPLE_DRIVE

    ReadFileL(certData, KDeviceCertFileName);

#else //RD_MULTIPLE_DRIVE

    RFs fs;

    TInt driveNumber( -1 );

    TChar driveLetter;

    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );

	User::LeaveIfError( fs.Connect() );

	fs.DriveToChar( driveNumber, driveLetter );

    fs.Close();

	TFileName deviceCertFileName;

	deviceCertFileName.Format( KDeviceCertFileName, (TUint)driveLetter );

    ReadFileL(certData, deviceCertFileName);

#endif

    CleanupStack::PushL(certData);

    cert = CX509Certificate::NewLC(*certData);

    aPublicKey = factory.RSAPublicKeyL(cert->PublicKey().KeyData());

    CleanupStack::PopAndDestroy(2); // cert, certData

    return KErrNone;

    }

TInt RRoapStorageClient::GetDevicePublicKeyDerL(

    HBufC8*& aPublicKey)

    {

    HBufC8* certData;

    CX509Certificate* cert;

#ifndef RD_MULTIPLE_DRIVE

    ReadFileL(certData, KDeviceCertFileName);

#else //RD_MULTIPLE_DRIVE

    RFs fs;

    TInt driveNumber( -1 );

    TChar driveLetter;

    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );

	User::LeaveIfError( fs.Connect() );

	fs.DriveToChar( driveNumber, driveLetter );

    fs.Close();

	TFileName deviceCertFileName;

	deviceCertFileName.Format( KDeviceCertFileName, (TUint)driveLetter );

    ReadFileL(certData, deviceCertFileName);

#endif

    CleanupStack::PushL(certData);

    cert = CX509Certificate::NewLC(*certData);

    aPublicKey = cert->PublicKey().KeyData().AllocL();

    CleanupStack::PopAndDestroy(2); // cert, certData

    return KErrNone;

    }

TInt RRoapStorageClient::GetDevicePublicKeyHashL(

    TDes8& aHash)

    {

    CSHA1* hash = NULL;

    HBufC8* key = NULL;

    GetDevicePublicKeyDerL(key);

    CleanupStack::PushL(key);

    hash = CSHA1::NewL();

    CleanupStack::PushL(hash);

    hash->Hash(*key);

    aHash.Copy(hash->Final());

    CleanupStack::PopAndDestroy(2); // hash, key

    return KErrNone;

    }

TInt RRoapStorageClient::GetDevicePrivateKeyL(

    CRSAPrivateKey*& aKey)

    {

    HBufC8* raw = NULL;

	TASN1DecInteger encInt;

    TInt pos = 0;

#ifndef RD_MULTIPLE_DRIVE

    ReadFileL(raw, KDevicePrivateKeyFileName);

#else //RD_MULTIPLE_DRIVE

    RFs fs;

    TInt driveNumber( -1 );

    TChar driveLetter;

    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );

	User::LeaveIfError( fs.Connect() );

	fs.DriveToChar( driveNumber, driveLetter );

    fs.Close();

	TFileName devicePrivateKeyFileName;

	devicePrivateKeyFileName.Format( 

	                    KDevicePrivateKeyFileName, (TUint)driveLetter );

    ReadFileL(raw, devicePrivateKeyFileName);

#endif

    CleanupStack::PushL(raw);

	TASN1DecGeneric gen(*raw);

	gen.InitL();

	pos += gen.LengthDERHeader();

	if (gen.Tag() != EASN1Sequence)

        {

		User::Leave(KErrArgument);

        }

    encInt.DecodeDERShortL(*raw, pos); // version

	RInteger modulus = encInt.DecodeDERLongL(*raw, pos);

    CleanupStack::PushL(modulus);

	RInteger publicExponent = encInt.DecodeDERLongL(*raw, pos);

    CleanupStack::PushL(publicExponent);

	RInteger privateExponent = encInt.DecodeDERLongL(*raw, pos);

    CleanupStack::PushL(privateExponent);

	aKey = CRSAPrivateKeyStandard::NewL(modulus, privateExponent);

    CleanupStack::Pop(); // privateExponent

    CleanupStack::PopAndDestroy();// publicExponent

    CleanupStack::Pop(); // modulus

    CleanupStack::PopAndDestroy(); // raw

    return KErrNone;

    }

TInt RRoapStorageClient::GetDeviceCertificateChainL(

    RPointerArray<HBufC8>& aCertChain)

    {

    RFs fs;

    RFile file;

    TFileName fileName;

    CDir* dir;

    HBufC8* cert;

    TInt size;

    TPtr8 ptr(0, 0);

    TInt itemsToPop = 0;

    TInt i;

    TEntry entry;

    CleanupClosePushL(aCertChain);

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

#ifndef RD_MULTIPLE_DRIVE

    User::LeaveIfError(fs.GetDir(KCertChainDir, KEntryAttMatchMask,

        ESortByName, dir));

    User::LeaveIfError(fs.SetSessionPath(KCertChainDir));

#else //RD_MULTIPLE_DRIVE

    TInt driveNumber( -1 );

    TChar driveLetter;

    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );

	fs.DriveToChar( driveNumber, driveLetter );

	TFileName certChainDir;

	certChainDir.Format( KCertChainDir, (TUint)driveLetter );

    User::LeaveIfError(fs.GetDir(certChainDir, KEntryAttMatchMask,

        ESortByName, dir));

    User::LeaveIfError(fs.SetSessionPath(certChainDir));

#endif

    CleanupStack::PushL(dir);

    GetDeviceCertificateL(cert);

    CleanupStack::PushL(cert);

    User::LeaveIfError(aCertChain.Append(cert));

    itemsToPop++;

    for (i = 0; i < dir->Count(); i++)

        {

        entry = (*dir)[i];

        if (entry.iName.Left(KSigningCertPrefix().Length()).CompareF(

            KSigningCertPrefix) == 0)

            {

            User::LeaveIfError(file.Open(fs, entry.iName, EFileRead));

            CleanupClosePushL(file);

            User::LeaveIfError(file.Size(size));

            cert = HBufC8::NewMax(size);

            ptr.Set(cert->Des());

            CleanupStack::PushL(cert);

            User::LeaveIfError(aCertChain.Append(cert));

            itemsToPop++;

            User::LeaveIfError(file.Read(ptr));

            CleanupStack::Pop(); // cert

            CleanupStack::PopAndDestroy(); // file

            CleanupStack::PushL(cert);

            }

        }

    CleanupStack::Pop(itemsToPop); // cert

    CleanupStack::PopAndDestroy(2); // fs, dir

    CleanupStack::Pop(); // aCertChain

    return KErrNone;

    }

TInt RRoapStorageClient::SignL(

    const TDesC8& aHash,

    HBufC8*& aSignature)

    {

    CRSAPrivateKey* privateKey = NULL;

    GetDevicePrivateKeyL(privateKey);

    CleanupStack::PushL(privateKey);

    aSignature = OmaCrypto::RsaPssSignHashL(privateKey, aHash);

    CleanupStack::PopAndDestroy(); // privateKey

    return KErrNone;

    }

TBool RRoapStorageClient::VerifyL(

    const TDesC8& aSignature,

    const TDesC8& aHash)

    {

    CRSAPublicKey* publicKey = NULL;

    TBool r = ETrue;

    GetDevicePublicKeyL(publicKey);

    CleanupStack::PushL(publicKey);

    r = OmaCrypto::RsaPssVerifyHashL(publicKey, aSignature, aHash);

    CleanupStack::PopAndDestroy(); // privateKey

    return r;

    }

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

// RoapStorageClient::GetRIContextL

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

//    

CDRMRIContext* RRoapStorageClient::GetRIContextL( const TDesC8& aRiID )

    {    

    return NULL;

    }

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

// RoapStorageClient::GetDomainContextL

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

//    

CDRMDomainContext* RRoapStorageClient::GetDomainContextL( const TDesC8& aDomainID )

    {    

    return NULL;

    }

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

// RRoapStorageClient::AddRIContextL

// Add a new RI Context to the ROAP storage

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

//

void RRoapStorageClient::AddRIContextL( const CDRMRIContext& aRiContext )

    {

    }

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

// RRoapStorageClient::AddDomainContextL

// Add a new RI Context to the ROAP storage

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

//

void RRoapStorageClient::AddDomainContextL( const CDRMDomainContext& aDomainContext,

                                            TKeyTransportScheme& aTransportScheme )

    {

    }

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

// RRoapStorageClient::DeleteRiContextL

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

//    

void RRoapStorageClient::DeleteRiContextL( const TDesC8& aRiID )

    {

    }

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

// RRoapStorageClient::DeleteDomainContextL

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

//    

void RRoapStorageClient::DeleteDomainContextL( const TDesC8& aDomainID )

    {

    }

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

// RRoapStorageClient::DeleteExpiredRIsL

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

//    

void RRoapStorageClient::DeleteExpiredRIsL( const TTime& aTime )

    {

    }

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

// RRoapStorageClient::DeleteExpiredDomainsL

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

//    

void RRoapStorageClient::DeleteExpiredDomainsL( const TTime& aTime )

    {

    }

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

// RRoapStorageClient::WhiteListURLExistsL

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

//    

TBool RRoapStorageClient::WhiteListURLExistsL( const TDesC8& aURL )

    {

    return EFalse;

    }         

//  End of File