/*

* Copyright (c) 2005-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:  Implementation of boot time integrity check program.

*

*/

// INCLUDE FILES

#include <e32cons.h>

#include <f32file.h>

#include <cctcertinfo.h>        // TCapabilitySet

#include <s32file.h> 

#include <signed.h>             // VerifySignatureL

#include <x500dn.h>             // ExactMatchL

#include <x509cert.h>           // x509

#include <swi/hashcontainer.h>

#include <swi/sisregistrysession.h>

#include <swi/sisregistryentry.h>

#include <swi/sisregistrypackage.h>

#include <hash.h>

#include <etelmm.h>             // For serial number size

#include "IntegrityCheck.h"

#include "InfoServerClient.h"

#include "IntegrityCheckDefs.h"

#include "IntegrityCheckClient.h"

#include "IntegrityCheckDebug.h"

// CONSTANTS

_LIT(KBTICThreadName,"BootIntegrityCheck"); 

_LIT(KBTICCertStoreZ,"z:\\resource\\swicertstore.dat");

_LIT(KBTICCertStoreCName,"updatedswicertstore.dat");

_LIT(KBTICCertStoreCPath,"c:\\resource\\swicertstore\\dat\\");

_LIT(KBTICDriveC,"c:\\");

_LIT(KBTICDriveCWildcard,"c:\\*");

_LIT(KBTICExtensionExe,"*.exe");

_LIT(KBTICSerialNumberFile,"*imei.txt");

_LIT(KBTICStarWildcard,"*\\");

/*

#ifdef __BTIC_BINARIES_CHECK_ENABLED

_LIT(KBTICSysPathC,"c:\\sys\\bin\\");

_LIT(KBTICCertStoreC,

    "c:\\resource\\swicertstore\\dat\\updatedswicertstore.dat"); 

_LIT(KBTICSysPathCWildcard,"c:\\sys\\bin\\*");

_LIT(KBTICExtensionDll,"*.dll");

_LIT(KBTICExtensionDat,"*.dat");

#endif //__BTIC_BINARIES_CHECK_ENABLED 

*/    

const TInt KBTICCapaCount = 2;  //Number of capabilities.

const TUint64 KBTIC_DRM = 64;   //0000 0000 0000 0000 0000 0000 0100 0000

const TUint64 KBTIC_TCB = 1;    //0000 0000 0000 0000 0000 0000 0000 0001

const TInt KBTICCabaWordOffset = 17; //File heder offset for capa. word @ 64bit.  

const TInt KBTICHashSize = 20; 

const TInt KBTICTryToOpen = 240;  //Try to open file. (240 x 0.5sec = 120sec)   

const TInt KBTICTryToCreate = 5; // Try to create process.

const TUint KBTICObserverTime = 1000000; // 1sec.

const TUint KBTICRunCount = 10; 

// MACROS

using namespace Swi;

// DATA TYPES

// FUNCTION PROTOTYPES

LOCAL_C TInt ThreadStartL();

LOCAL_C TInt ReadCertificatesL( 

    RFs& aFs, 

    const TDesC& aPath,     

    RPointerArray<CX509Certificate>& aX509CertArray,

    RPointerArray<TCapabilitySet>& aCapabilityArray  );

LOCAL_C TBool ValidateCertStoreL(

    RFs& aFs,     

    RPointerArray<CX509Certificate>& aX509CertArray,

    RPointerArray<TCapabilitySet>& aCapaArray,

    const TDesC& aCertStoreFileName,

    const TDesC& aCertStoreFilePath ); 

LOCAL_C TBool ValidateProvisonerCertStoreL(

    RFs& aFs,                                           

    RPointerArray<CX509Certificate>& aX509CertArray,

    RPointerArray<TCapabilitySet>& aCapaArray,     

    const TDesC& aCertStoreFileName,

    const TDesC& aCertStoreFilePath,

    RSisRegistryEntry& aEntry );

LOCAL_C TBool ValidateSymbianCertStoreL(

    RFs& aFs,                                           

    RPointerArray<CX509Certificate>& aX509CertArray,

    RPointerArray<TCapabilitySet>& aCapaArray,              

    RSisRegistryEntry& aEntry,

    RPointerArray<HBufC>& aUpdaterExePaths ); 

LOCAL_C TBool RunUpdaterL( RFs& aFs, RPointerArray<HBufC>& aUpdaterExePaths );    

LOCAL_C TBool DeleteAllFilesL( RFs& aFs, const TDesC& aFolderPath );                

LOCAL_C TBool SearchFilesFromArrayL( 

    RPointerArray<HBufC>& aSourceArray,

    const TDesC& aDriveAndPath,

    RPointerArray<HBufC>& aStringArray, 

    RPointerArray<HBufC>& aFilesArray );

LOCAL_C TBool SearchValidCertificateL( 

    RSisRegistryEntry& aEntry, 

    RPointerArray<CX509Certificate>& aX509CertArray,

    RPointerArray<TCapabilitySet>& aCertCapaArray,

    TUint64 aCapability );

LOCAL_C TCapability GetCapability( TUint64 aCapability );

LOCAL_C TBool VerifyHashL(    

    RSisRegistryEntry& aEntry, 

    RPointerArray<HBufC>& aPathArray,

    RPointerArray<HBufC8>& aHashArray );

LOCAL_C TBool CompareToRegisteryHashL( 

    RSisRegistryEntry& aEntry, 

    TDesC& aEntryFile, 

    TDesC8& aHashBuffer ); 

LOCAL_C TBool CheckSerialNumberL( RFs& aFs, const TDesC& aFileName ); 

LOCAL_C void CorruptFileL( RFs& aFs, const TDesC& aFileName );                              

LOCAL_C TBool CheckCapabilityWordAndCalcHashL( 

    RFs& aFs, 

    TBool aCheckCapa,

    TUint64* aCapaVector,    

    RPointerArray<HBufC>& aSourceArray,

    RPointerArray<HBufC>& aFilesArray,

    RPointerArray<HBufC8>& aHashArray,

    RArray<TUint64>& aCapaArray );

/*

#ifdef __BTIC_BINARIES_CHECK_ENABLED

LOCAL_C void RenameFileL( RFs& aFs, const TDesC& aFileName );

LOCAL_C void UniteCertArraysL(     

    RPointerArray<CX509Certificate>& aTargetCertArray,

    RPointerArray<CX509Certificate>& aSourceCertArray );

LOCAL_C void UniteCapaArraysL( 

    RPointerArray<TCapabilitySet>& aTargetCapaArray,

    RPointerArray<TCapabilitySet>& aSourceCapaArray );     

LOCAL_C void CheckBinariesL( 

    RFs& aFs, 

    RPointerArray<CX509Certificate>& aX509CertArray,

    RPointerArray<TCapabilitySet>& aCertCapaArray );  

LOCAL_C void FindFilesL( 

    RFs& aFs, 

    const TDesC& aPath,

    const TDesC& aSearchString,    

    RPointerArray<HBufC>& aFoundFilesArray );

LOCAL_C TBool FindMatchFromSisPackageL( 

    RFs& aFs,    

    RPointerArray<HBufC>& aFilesArray, 

    RPointerArray<HBufC8>& aHashArray, 

    RArray<TUint64>& aCapaArray,

    RPointerArray<CX509Certificate>& aX509CertArray,

    RPointerArray<TCapabilitySet>& aCertCapaArray ); 

#endif //__BTIC_BINARIES_CHECK_ENABLED

*/     

// FORWARD DECLARATIONS

// LOCAL FUNCTION PROTOTYPES

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

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

// E32Main()

// Main for ARM environment.

// Returns: KErrNone if successful  

//          Othervice some system error code.

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

//

GLDEF_C TInt E32Main()

    {

    BTIC_TRACE_PRINT_ALLOC_CELLS("[BOOT INTECRITY CHECK] Main cell count = %d");  

    TInt err = KErrNone;

    CTrapCleanup* cleanup = CTrapCleanup::New();

    if ( !cleanup )

        {

        return KErrNoMemory;

        }

    TRAP( err, ThreadStartL() );

    BTIC_TRACE_PRINT_NUM("[BOOT INTECRITY CHECK] Main TRAP error = %d", err);

    delete cleanup;

    BTIC_TRACE_PRINT_ALLOC_CELLS("[BOOT INTECRITY CHECK] Main cell count = %d"); 

    return err;

    }

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

// ThreadStart()

// 

// This is programs main.

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

//

LOCAL_C TInt ThreadStartL()

    {                                                       

    BTIC_TRACE_PRINT("[BOOT INTECRITY CHECK] START PROGRAM");    

    __UHEAP_MARK;

    BTIC_TRACE_PRINT_ALLOC_CELLS("Start Cell count = %d");  

    BTIC_TRACE_PRINT("Rename thread to BootIntegrityCheck");

    // Rename thread as SecEnvInit.

    User::RenameThread( KBTICThreadName );  

    // This should be read with feature manager etc. but since we 

    // only support certificate database checking this is ok.

    TBool binariesCheckEnbled = EFalse;   

    TBool certFileFound = EFalse; 

    TInt err = KErrNone; 

    TInt pushToStack = 0; 

    // GET BOOT REASON   

    BTIC_TRACE_PRINT("Get boot reason");     

    TBool bootReasonFormat = EFalse;   

    RIntegrityCheckClient bticServer;

    err = bticServer.Connect();    

    BTIC_TRACE_PRINT_NUM("BTIC Server connect error = %d", err );

    if ( err == KErrNone )

        {            

        CleanupClosePushL( bticServer );                                

        TInt bootReason = KErrNone;     

        // Get boot reason from btic server.

        err = bticServer.GetSWBootReason( bootReason );                          

        BTIC_TRACE_PRINT_NUM("GetSWBootReason error = %d", err );

        if ( err == KErrNone )

            {                                  

            BTIC_TRACE_PRINT_NUM("Boot Reason number = %d", bootReason );

            if ( bootReason == EBTICRestoreFactorySetDeep )

                {                                                                

                BTIC_TRACE_PRINT("[BOOT INTECRITY CHECK] Boot reason: FORMAT");  

                bootReasonFormat = ETrue;

                }                                   

            }             

        CleanupStack::PopAndDestroy(); //bticServer                                  

        }

    // OPEN FILE SERVER    

    BTIC_TRACE_PRINT("Open FS session");

    RFs fs;

    // Connect to file server.

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

    CleanupClosePushL( fs );

    pushToStack++;

    // Find SWICertStore.dat in C drive.

    TFindFile find( fs ); 

    TBool certStoreOk = EFalse;  

    CDir* entryList = NULL;   

    HBufC* certStoreFilePath = NULL; 

    HBufC* certStoreFileName = NULL; 

    BTIC_TRACE_PRINT("Find C SWI certificate store");    

    // Get all files from folder. 

    if ( KErrNone == fs.GetDir ( 

        KBTICCertStoreCPath, 

        KEntryAttNormal,

        ESortByName|EDirsFirst, 

        entryList ) )

        {     

        if ( entryList )

            {

            CleanupStack::PushL( entryList );

            TInt count = entryList->Count(); 

            // If file is found.            

            if ( count )

                {                                              

                BTIC_TRACE_PRINT("Store file found");

                // Get the highest version certstore file

                const TEntry& entry = (*entryList)[count - 1];                                

                // Make temp buffer for file path. 

                TBuf<KMaxFileName> path( KBTICCertStoreCPath );

                path.Append( entry.iName );

                certStoreFilePath = path.AllocLC(); 

                pushToStack++;                              

                certStoreFileName = entry.iName.AllocLC(); 

                pushToStack++;                                                              

                certFileFound = ETrue; 

                CleanupStack::Pop(); //certStoreFilePath

                CleanupStack::Pop(); //certStoreFileName

                CleanupStack::PopAndDestroy( 1, entryList ); 

                CleanupStack::PushL( certStoreFilePath );                         

                CleanupStack::PushL( certStoreFileName );                           

                }

            else

                {

                BTIC_TRACE_PRINT("No store file present");

                CleanupStack::PopAndDestroy( 1, entryList ); 

                }                                                

            }

        }

    BTIC_TRACE_PRINT("Check boot reason");  

    // Check boot reason. If certificate store file is found start active file

    // observer which checks that file is deleted. If not continue checking.        

    if ( bootReasonFormat )

        {

        BTIC_TRACE_PRINT("Boot reason format");    

        if( certFileFound )

            {

            BTIC_TRACE_PRINT("Start active file observer"); 

            TInt status = KErrUnknown;

            // Create active scheduler.

            CActiveScheduler* threadScheduler = new CActiveScheduler;

            CleanupStack::PushL( threadScheduler );

            pushToStack++;

            CActiveScheduler::Install( threadScheduler );

            // Create file observer object.

            CActiveFileObserver* observer =

                CActiveFileObserver::NewL( fs, *certStoreFilePath, status );

            CleanupStack::PushL( observer );

            pushToStack++;

            BTIC_TRACE_PRINT("Start active scheduler");            

            CActiveScheduler::Start();            

            BTIC_TRACE_PRINT_NUM("File observer status = %d", status );

            if ( status == KErrNone )

                {

                // Boot reason is fromat and certificate file is deleted.

                // Stop checking and exit.                    

                BTIC_TRACE_PRINT("Stop checking and exit");

                certFileFound = EFalse;   

                binariesCheckEnbled = EFalse;                 

                }

            }

        else

            {  

            // Boot reason is fromat and no certificate file is found.

            // Stop checking and exit.      

            BTIC_TRACE_PRINT("Stop checking and exit");

            certFileFound = EFalse;   

            binariesCheckEnbled = EFalse;        

            }    

        }

    BTIC_TRACE_PRINT_NUM("Updated store read enabled(1) = %d",certFileFound);

    BTIC_TRACE_PRINT_NUM("Binaries check enabled(0) = %d",binariesCheckEnbled);           

    // Create pointer array for root certificates.  

    RPointerArray<CX509Certificate> x509CertArray;     

    RPointerArray<TCapabilitySet> certCapaArray;

    TInt fileError = 0;

    // Read root certificates if needed.      

    if ( certFileFound || binariesCheckEnbled )

        {                                    

        // Get root certificates to x509 format.  

        fileError = 

          ReadCertificatesL( 

              fs, 

              KBTICCertStoreZ, 

              x509CertArray, 

              certCapaArray );

        // Can't read root certificates or array is empty. 

        // Let's return and try this in next boot.    

        if ( fileError || x509CertArray.Count() == 0 )

            {

            BTIC_TRACE_PRINT("ERROR Can't read root certificates ! ! !");

            CleanupStack::PopAndDestroy( pushToStack );

            x509CertArray.ResetAndDestroy();                   

            certCapaArray.ResetAndDestroy();

            User::Leave( fileError );

            }               

        }

    // Create temporary pointer array for C-drive updated certificates. 

    RPointerArray<CX509Certificate> tempCertArray;  

    RPointerArray<TCapabilitySet> tempCapaArray;    

    // If candidate for certstore file is found read it and validate file.

    if ( certFileFound )

        {        

        BTIC_TRACE_PRINT("Read certificates from C");       

        // Read certificates from C drive and set them to x509 format         

        TRAP( err ,

            fileError = ReadCertificatesL( 

                fs, 

                *certStoreFilePath, 

                tempCertArray,                                          

                tempCapaArray ) );

        BTIC_TRACE_PRINT_NUM("C read file error (0) = %d", fileError );

        BTIC_TRACE_PRINT_NUM("C read Trap err (0) = %d", err );                

        // If ReadCertificatesL function leaves, we assume that something is

        // tampered and the file is corrupted. However if function returns

        // an error code, file is not corrupted.           

        if ( err )

            {

            fileError = err;

            TRAP_IGNORE( CorruptFileL( fs, *certStoreFilePath ) );

            }                     

        // If there is no error when constructing a permanent file store object

        // let's continue.                      

        if ( fileError == KErrNone )

            {

            BTIC_TRACE_PRINT("Validate cert store");

            // Validate the certstore in C if certs are found. 

            TRAP( err, 

                  certStoreOk = ValidateCertStoreL( 

                        fs, 

                        x509CertArray, 

                        certCapaArray, 

                        *certStoreFileName,

                        *certStoreFilePath ) );

            BTIC_TRACE_PRINT_NUM("Trap err (0) = %d", err );

            BTIC_TRACE_PRINT_NUM("Cert storage valid (1) = %d", certStoreOk ); 

            // If validation fails or function leaves we will assume

            // that database is tempered and it will be corrupted. 

            // In practice this mean that all binaries signed with 

            // certificates in C database will be corrupted.                                                                            

            if ( ! certStoreOk || err != KErrNone )

                {                                                    

                TRAP_IGNORE( CorruptFileL( fs, *certStoreFilePath ) );

                } 

            BTIC_TRACE_PRINT("\nStore validation complete"); 

            }                                                

        }  

/*                               

#ifdef __BTIC_BINARIES_CHECK_ENABLED

    // If found cert store is valid unite arrays.

    if ( certStoreOk )

        {

        UniteCertArraysL( x509CertArray, tempCertArray ); 

        // Reset tempCertArray because x509CertArray owns entrys now.

        tempCertArray.Reset();

        UniteCapaArraysL( certCapaArray, tempCapaArray );

        // Reset tempCapaArray because certCapaArray owns entrys now.               

        tempCapaArray.Reset();

        }

    // Check that certificates are found before checking binaries.

    if ( x509CertArray.Count() )

        {

        // Check that cert array and capa array has same amount of entrys.

        // If amount is diffrent do not check binaries. Something is wrong.

        if ( x509CertArray.Count() == certCapaArray.Count() )

            {

            // Check that binaries found in C: are istalled from a valid SIS 

            // pagaces and binary's hash is valid.        

            CheckBinariesL( fs, x509CertArray, certCapaArray );              

            BTIC_TRACE_PRINT("\nBinaries check complete\n");

            }                     

        }

#endif //__BTIC_BINARIES_CHECK_ENABLED

*/      

    BTIC_TRACE_PRINT("\nProgram complete\n");

    // DELETE ALL ARRAYS AND ARRAY CONTENT    

    x509CertArray.ResetAndDestroy();                

    tempCertArray.ResetAndDestroy();

    certCapaArray.ResetAndDestroy();

    tempCapaArray.ResetAndDestroy();  

    CleanupStack::PopAndDestroy( pushToStack ); //fs, buffers

    BTIC_TRACE_PRINT("UHEAP MARK END");

    __UHEAP_MARKEND;

    BTIC_TRACE_PRINT_ALLOC_CELLS("End Cell count = %d");

    BTIC_TRACE_PRINT("[BOOT INTECRITY CHECK] PROGRAM END");   

    return KErrNone;