/*

* Copyright (c) 2002-2010 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:  OMA DRM 2.0 Key Storage

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <asymmetric.h>

#include <symmetric.h>

#include <hash.h>

#include <asn1dec.h>

#include <x509cert.h>

#include <etelmm.h>

#include <mmtsy_names.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif

#include "DrmKeyStorage.h"

#include "DrmStdKeyStorage.h"

#ifdef _DEBUG

#define LOGGING

#endif

#ifdef LOGGING

_LIT(KLogDir, "DRM");

_LIT(KLogName, "KeyStorage.log");

#include "flogger.h"

#define LOG(string) \

    RFileLogger::Write(KLogDir, KLogName, \

        EFileLoggingModeAppend, string);

#define LOGHEX(buffer) \

    RFileLogger::HexDump(KLogDir, KLogName, \

        EFileLoggingModeAppend, _S(""), _S(""), \

        buffer.Ptr(), buffer.Length());

#else

#define LOG(string)

#define LOGHEX(buffer)

#endif

#pragma message("Compiling DRM Std KeyStorage..")

// LOCAL CONSTANTS AND MACROS

const TInt KKeyLength = 128;

const TInt KWaitingTime = 2000000; // 2 sec

#ifdef RD_MULTIPLE_DRIVE

_LIT(KKeyStoragePath, "%c:\\private\\101F51F2\\PKI\\");

_LIT(KRomKeyStoragePath, "%c:\\private\\101F51F2\\PKI\\");

#else

_LIT(KKeyStoragePath, "c:\\private\\101F51F2\\PKI\\");

_LIT(KRomKeyStoragePath, "z:\\private\\101F51F2\\PKI\\");

#endif

_LIT(KDeviceKeyFileName, "DevicePrivateKey.der");

_LIT(KDeviceCertFileName, "DeviceCert.der");

_LIT(KSingingCertFmt, "SigningCert%02d.der");

_LIT(KSingingCertPattern, "SigningCert*");

_LIT8(KDefaultKey, "0000000000000000");

#ifdef RD_MULTIPLE_DRIVE

_LIT(KSerialNumberFile, "%c:\\private\\101F51F2\\rdbserial.dat");

_LIT(KUdtCertFileName, "%c:\\private\\101F51F2\\PKI\\UdtCertificate.der");

#else

_LIT(KSerialNumberFile, "c:\\private\\101F51F2\\rdbserial.dat");

_LIT(KUdtCertFileName, "z:\\private\\101F51F2\\PKI\\UdtCertificate.der");

#endif

_LIT(KCmla, "CMLA");

_LIT(KPadding, "\x0");

NONSHARABLE_STRUCT( TUnloadModule )

    {

    RTelServer* iServer;

    const TDesC* iName;

    };

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

LOCAL_C void DoUnloadPhoneModule( TAny* aAny );

LOCAL_C void WriteFileL(RFs& aFs, const TDesC& aName, const TDesC8& aData)

    {

    RFile file;

    User::LeaveIfError(file.Replace(aFs, aName, EFileWrite));

    User::LeaveIfError(file.Write(aData));

    file.Close();

    }

LOCAL_C void ReadFileL(RFs& aFs, const TDesC& aName, HBufC8*& aContent)

    {

    RFile file;

    TInt size = 0;

    User::LeaveIfError(file.Open(aFs, 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(); // file

    }

HBufC8* I2OSPL(

    RInteger& aInt, TInt& aKeySize )

    {

    HBufC8* integer = aInt.BufferLC();

    if (integer->Length() < aKeySize)

        {

        HBufC8* r = HBufC8::NewLC(aKeySize);

        TPtr8 ptr(r->Des());

        for(TInt i = integer->Length(); i < aKeySize; i++)

            {

            ptr.Append(KPadding());

            }

        ptr.Append(*integer);

        CleanupStack::Pop(r);

        CleanupStack::PopAndDestroy(integer);

        return r;

        }

    else

        {

        CleanupStack::Pop(integer);

        return integer;

        }

    }

RInteger OS2IPL(

    const TDesC8& aOctetStream)

    {

    RInteger r;

    TInt i;

    r = RInteger::NewL(0);

    for (i = 0; i < aOctetStream.Length(); i++)

        {

        r *= 256;

        r += aOctetStream[i];

        }

    return r;

    }

void DoUnloadPhoneModule( TAny* aAny )

    {

    __ASSERT_DEBUG( aAny, User::Invariant() );

    TUnloadModule* module = ( TUnloadModule* ) aAny;

    module->iServer->UnloadPhoneModule( *( module->iName ) );

    }

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

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

// CDrmStdKeyStorage* CDrmStdKeyStorage::NewL

//

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

//

EXPORT_C CDrmStdKeyStorage* CDrmStdKeyStorage::NewL(RLibrary aLibrary)

    {

    CDrmStdKeyStorage* self = new (ELeave) CDrmStdKeyStorage(aLibrary);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CDrmStdKeyStorage::CDrmStdKeyStorage

//

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

//

CDrmStdKeyStorage::CDrmStdKeyStorage(RLibrary aLibrary):

    iFileMan(NULL),

    iRootSelected(EFalse),

    iKey(NULL),

    iImei(NULL),

    iLibrary(aLibrary)

    {

    }

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

// CDrmStdKeyStorage::ConstructL

//

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

//

void CDrmStdKeyStorage::ConstructL()

    {

    LOG(_L("CDrmStdKeyStorage::ConstructL ->"));

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

    iFileMan = CFileMan::NewL(iFs);

#ifdef __DRM_OMA2

    TRAP_IGNORE( SelectDefaultRootL() ); // Allow startup anyway.

#endif

    iDeviceSpecificKey.Copy(KDefaultKey);

    LOG(_L("CDrmStdKeyStorage::ConstructL <-"));

    }

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

// MDrmKeyStorage::~MDrmKeyStorage

//

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

//

MDrmKeyStorage::~MDrmKeyStorage()

    {

    }

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

// DrmStdKeyStorage::~CDrmStdKeyStorage

//

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

//

CDrmStdKeyStorage::~CDrmStdKeyStorage()

    {

    LOG(_L("CDrmStdKeyStorage::~CDrmStdKeyStorage ->"));

    delete iFileMan;

    delete iKey;

    delete iImei; iImei = NULL;

    iFs.Close();

    //iLibrary.Close();

    LOG(_L("CDrmStdKeyStorage::~CDrmStdKeyStorage <-"));

    }

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

// DrmStdKeyStorage::ModulusSize

//

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

//

TInt CDrmStdKeyStorage::ModulusSize()

    {

    LOG(_L("CDrmStdKeyStorage::ModulusSize ->"));

    if(iKey == NULL)

        {

        return KErrGeneral;

        }

    LOG(_L("CDrmStdKeyStorage::ModulusSize <-"));

    return iKey->N().BitCount();

    }

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

// DrmStdKeyStorage::SelectTrustedRootL

//

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

//

void CDrmStdKeyStorage::SelectTrustedRootL(

    const TDesC8& aRootKeyHash)

    {

    TFileName fileName;

    TEntry entry;

    TInt i;

    LOG(_L("CDrmStdKeyStorage::SelectTrustedRootL ->"));

    LOG(aRootKeyHash);

    if (aRootKeyHash.Length() != 0)

        {

#ifndef RD_MULTIPLE_DRIVE

        fileName.Copy(KKeyStoragePath);

#else //RD_MULTIPLE_DRIVE

        TFileName tempPath;

        TInt driveNumber( -1 );

        TChar driveLetter;

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

        iFs.DriveToChar( driveNumber, driveLetter );

        tempPath.Format( KKeyStoragePath, (TUint)driveLetter );

        fileName.Copy(tempPath);

#endif

        for (i = 0; i < SHA1_HASH; i++)

            {

            fileName.AppendNumFixedWidth(aRootKeyHash[i], EHex, 2);

            }

        fileName.Append('\\');

        if (iFs.Entry(fileName, entry) != KErrNone)

            {

#ifndef RD_MULTIPLE_DRIVE

            fileName.Copy(KRomKeyStoragePath);

#else //RD_MULTIPLE_DRIVE

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

            iFs.DriveToChar( driveNumber, driveLetter );

            tempPath.Format( KRomKeyStoragePath, (TUint)driveLetter );

            fileName.Copy(tempPath);

#endif

            for (i = 0; i < SHA1_HASH; i++)

                {

                fileName.AppendNumFixedWidth(aRootKeyHash[i], EHex, 2);

                }

            fileName.Append('\\');

            // check that the path exists

            User::LeaveIfError(iFs.Entry(fileName, entry));

            }

        User::LeaveIfError(iFs.SetSessionPath(fileName));

        InitializeKeyL();

        CheckRootForCmlaL();

        iRootSelected = ETrue;

        }

    else

        {

        SelectDefaultRootL();

        }

    LOG(_L("CDrmStdKeyStorage::SelectTrustedRootL <-"));

    }

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

// DrmStdKeyStorage::SelectDefaultRootL

//

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

//

void CDrmStdKeyStorage::SelectDefaultRootL()

    {

    CDir* dir = NULL;

    TFileName dirName;

    TBool found = EFalse;

    LOG(_L("CDrmStdKeyStorage::SelectDefaultRootL ->"));

#ifndef RD_MULTIPLE_DRIVE

    if (iFs.GetDir(KKeyStoragePath, KEntryAttDir, ESortByName, dir) == KErrNone)

#else //RD_MULTIPLE_DRIVE

    TFileName tempPath;

    TInt driveNumber( -1 );

    TChar driveLetter;

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

    iFs.DriveToChar( driveNumber, driveLetter );

    tempPath.Format( KKeyStoragePath, (TUint)driveLetter );

    if (iFs.GetDir(tempPath, KEntryAttDir, ESortByName, dir) == KErrNone)

#endif

        {

        __UHEAP_MARK;

        LOG(_L("  Checking keys on C:"));

        CleanupStack::PushL(dir);

        if (dir->Count() >= 1)

            {

#ifndef RD_MULTIPLE_DRIVE

            dirName.Copy(KKeyStoragePath);

#else //RD_MULTIPLE_DRIVE

            dirName.Copy(tempPath);

#endif

            dirName.Append((*dir)[0].iName);

            dirName.Append('\\');

            User::LeaveIfError(iFs.SetSessionPath(dirName));

            found = ETrue;

            }

        CleanupStack::PopAndDestroy(dir);

        __UHEAP_MARKEND;

        }

#ifndef RD_MULTIPLE_DRIVE

    if (!found && iFs.GetDir(KRomKeyStoragePath, KEntryAttDir, ESortByName, dir) == KErrNone)

#else //RD_MULTIPLE_DRIVE

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

    iFs.DriveToChar( driveNumber, driveLetter );

    tempPath.Format( KRomKeyStoragePath, (TUint)driveLetter );

    if (!found && iFs.GetDir(tempPath, KEntryAttDir, ESortByName, dir) == KErrNone)

#endif

        {

        LOG(_L("  Checking keys on Z:"));

        CleanupStack::PushL(dir);

        if (dir->Count() < 1)

            {

            User::Leave(KErrGeneral);

            }

#ifndef RD_MULTIPLE_DRIVE

        dirName.Copy(KRomKeyStoragePath);

#else //RD_MULTIPLE_DRIVE

        dirName.Copy(tempPath);

#endif

        dirName.Append((*dir)[0].iName);

        dirName.Append('\\');

        User::LeaveIfError(iFs.SetSessionPath(dirName));

        CleanupStack::PopAndDestroy(dir);

        found = ETrue;

        }

    if (!found)

        {

        User::Leave(KErrGeneral);

        }

    InitializeKeyL();

    CheckRootForCmlaL();

    iRootSelected = ETrue;

    LOG(_L("CDrmStdKeyStorage::SelectDefaultRootL <-"));

    }

TBool CDrmStdKeyStorage::SelectedRootIsCmla()

    {

    return iRootIsCmla;

    }

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

// DrmStdKeyStorage::GetTrustedRootsL

//

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

//

void CDrmStdKeyStorage::GetTrustedRootsL(

    RPointerArray<HBufC8>& aRootList)

    {

    CDir* dir = NULL;

    TInt i;

    TInt j;

    TBuf8<SHA1_HASH> hash;

    TEntry entry;

    TUint8 c;

    TInt r = KErrNone;

    LOG(_L("CDrmStdKeyStorage::GetTrustedRootsL ->"));

    aRootList.ResetAndDestroy();

#ifndef RD_MULTIPLE_DRIVE

    if (iFs.GetDir(KKeyStoragePath, KEntryAttDir, ESortByName, dir) == KErrNone)

#else //RD_MULTIPLE_DRIVE

    TFileName tempPath;

    TInt driveNumber( -1 );

    TChar driveLetter;

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

    iFs.DriveToChar( driveNumber, driveLetter );

    tempPath.Format( KKeyStoragePath, (TUint)driveLetter );

    if (iFs.GetDir(tempPath, KEntryAttDir, ESortByName, dir) == KErrNone)

#endif

        {

        LOG(_L("  Getting roots on C:"));

        CleanupStack::PushL(dir);

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

            {

            entry = (*dir)[i];

            hash.SetLength(0);

            LOG(entry.iName);

            r = KErrNone;

            for (j = 0; r == KErrNone && j < SHA1_HASH; j++)

                {

                TLex lex(entry.iName.Mid(j * 2, 2));

                r = lex.Val(c, EHex);

                hash.Append(c);

                }

            if (r == KErrNone)

                {

                aRootList.Append(hash.AllocL());

                }

            }

        CleanupStack::PopAndDestroy(dir);

        }