/*

* Copyright (c) 2005 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:  IMPS SAP Settings Store implementation.

*

*/

//  INCLUDES

#include 	"CIMPSSAPSecurer.h"

#include	"IMPSSAPSettingsStoreDefinitions.h"

#include    <3des.h> 		//3des encryption/decryption

#include	<etelmm.h> 		// for getting the IMEI

#include	<mmtsy_names.h>

#include 	<symmetric.h>

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

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

// CIMPSSAPSecurer::CIMPSSAPSecurer

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

// might leave.

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

//

CIMPSSAPSecurer::CIMPSSAPSecurer()

    {

    }

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

// CIMPSSAPSecurer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIMPSSAPSecurer::ConstructL()

    {

    // Get the encryption key

    iEncryptionKey = HBufC8::NewL( KSSS3DESKeySize );

    TPtr8 keyPtr( iEncryptionKey->Des() );

    GetPwdKeyL( keyPtr );

    // Create encryptor and decryptor

    iEncryptor = C3DESEncryptor::NewL( keyPtr );

    iDecryptor = C3DESDecryptor::NewL( keyPtr );

    iTransformBlock = HBufC8::NewMaxL( iEncryptor->BlockSize() );

    }

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

// CIMPSSAPSecurer::NewL

// Two-phased constructor.

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

//

CIMPSSAPSecurer* CIMPSSAPSecurer::NewL()

    {

    CIMPSSAPSecurer* self = new( ELeave ) CIMPSSAPSecurer();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CIMPSSAPSecurer::~CIMPSSAPSecurer()

    {

    delete iTransformBlock;

    delete iEncryptionKey;

    delete iEncryptor;

    delete iDecryptor;

    }

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

// CIMPSSAPSecurer::EncryptPwdL()

// Encrypts password

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

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

//

HBufC* CIMPSSAPSecurer::EncryptPwdL( const TDesC& aPwdBuffer )

    {

    HBufC* encrypted;

    // first check for 0 length buffers

    if ( aPwdBuffer.Length() == 0 )

        {

        encrypted = HBufC::NewMaxL( 0 );

        return encrypted;

        }

    // character for padding

    TChar KPad( 0x00 );

    TUint8* tempPtr = ( TUint8* ) aPwdBuffer.Ptr();

    TPtr8 buf( tempPtr, aPwdBuffer.Size(), aPwdBuffer.Size() );

    TInt bufSize = aPwdBuffer.Size();

    const TInt blocksize = iEncryptor->BlockSize();

    const TInt remainder = bufSize % blocksize;

    // make the result buffer big enough for the padding ==>

    // round upwards to next multiple of blocksize

    if ( remainder == 0 )

        {

        encrypted = HBufC::NewMaxLC( bufSize / 2 );

        }

    else

        {

        encrypted = HBufC::NewMaxLC( ( bufSize + ( blocksize - remainder )  ) / 2 );

        }

    TUint8* tempEncPtr = ( TUint8* ) encrypted->Ptr();

    TPtr8 encPtr( tempEncPtr, NULL, encrypted->Des().MaxSize() );

    TPtr8 transformPtr( iTransformBlock->Des() );

    TInt offset( 0 );

    while ( offset <= bufSize - blocksize )

        {

        transformPtr = buf.Mid( offset, blocksize );

        iEncryptor->Transform( transformPtr );

        encPtr.Append( transformPtr );

        offset += blocksize;

        }

    // Handle last block. If last block is not 8 characters long add padding

    // nulls to end of it.

    if ( remainder != 0 )

        {

        transformPtr = buf.Mid( offset );

        transformPtr.AppendFill( KPad, blocksize - remainder );

        iEncryptor->Transform( transformPtr );

        encPtr.Append( transformPtr );

        }

    CleanupStack::Pop( encrypted );

    return encrypted;

    }

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

// CIMPSSAPSecurer::DecryptPwdL()

// Decrypts password

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

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

//

HBufC* CIMPSSAPSecurer::DecryptPwdL( const TDesC& aPwdBuffer )

    {

    HBufC* decrypted;

    // first check for 0 length buffers

    if ( aPwdBuffer.Length() == 0 )

        {

        decrypted = HBufC::NewMaxL( 0 );

        return decrypted;

        }

    // character for padding

    TChar KPad( 0x00 );

    TUint8* tempPtr = ( TUint8* ) aPwdBuffer.Ptr();

    TPtr8 buf( tempPtr, aPwdBuffer.Size(), aPwdBuffer.Size() );

    TInt bufSize = aPwdBuffer.Size();

    const TInt blocksize = iEncryptor->BlockSize();

    const TInt remainder = bufSize % blocksize;

    // make the result buffer big enough for the padding ==>

    // round upwards to next multiple of blocksize

    if ( remainder == 0 )

        {

        decrypted = HBufC::NewMaxLC( bufSize / 2 );

        }

    else

        {

        decrypted = HBufC::NewMaxLC( ( bufSize + ( blocksize - remainder ) ) / 2 );

        }

    TUint8* tempDecPtr = ( TUint8* ) decrypted->Ptr();

    TPtr8 decPtr( tempDecPtr, NULL, decrypted->Des().MaxSize() );

    TPtr8 transformPtr( iTransformBlock->Des() );

    TInt offset( 0 );

    while ( offset <= bufSize - blocksize )

        {

        transformPtr = buf.Mid( offset, blocksize );

        iDecryptor->Transform( transformPtr );

        decPtr.Append( transformPtr );

        offset += blocksize;

        }

    // Remove padding nulls from end of the decrypted password

    if ( remainder != 0 )

        {

        transformPtr = buf.Mid( offset );

        transformPtr.AppendFill( KPad, blocksize - remainder );

        iDecryptor->Transform( transformPtr );

        decPtr.Append( transformPtr );

        }

    TInt padStart( decrypted->Des().Locate( KPad ) );

    if ( padStart != KErrNotFound )

        {

        decrypted->Des().SetLength( padStart );

        }

    CleanupStack::Pop( decrypted );

    return decrypted;

    }

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

// CIMPSSAPSecurer::FetchIMEI()

//

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

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

//

void CIMPSSAPSecurer::FetchIMEI( TPtr8& aImei )

    {

    // Create a fake serial number for emulator or for fallback if

    // we're unable to get the real IMEI from hardware

    TBuf<RMobilePhone::KPhoneSerialNumberSize> fakeSerialNumber( KSAPFakeIMEI );

    aImei.Copy( fakeSerialNumber );

#ifndef __WINS__

    RMobilePhone::TMobilePhoneIdentityV1 phoneIdentity;

    // initializations

    RMobilePhone phone;

    RTelServer server;

    TRAPD( err,

        {

        err = server.Connect();

        User::LeaveIfError( err );

        CleanupClosePushL( server );

        err = server.LoadPhoneModule( KMmTsyModuleName );

        if ( err != KErrNone && err != KErrAlreadyExists )

            {

            User::Leave( err );

            }

        err = phone.Open( server, KMmTsyPhoneName );

        User::LeaveIfError( err );

        CleanupClosePushL( phone );

        TUint32 identityCaps;

        err = phone.GetIdentityCaps( identityCaps );

        User::LeaveIfError( err );

        if ( identityCaps & RMobilePhone::KCapsGetModel )

            {

            TRequestStatus status;

            phone.GetPhoneId( status, phoneIdentity );

            // No choice but to wait for the request to complete.

            User::WaitForRequest( status ); // CSI: 94 #

            User::LeaveIfError( status.Int() ); // CSI: 42 #

            // Inside trap

            }

        else // In case we didn't have capabilities to get real IMEI

            {

            User::Leave( KErrNotSupported ); // CSI: 42 #

            // Inside trap

            }

        CleanupStack::PopAndDestroy( 2 ); // server, phone

        } );

    // Fetching the IMEI went fine.

    if ( err == KErrNone )

        {

        aImei.Copy( phoneIdentity.iSerialNumber );

        }

#endif // __WINS__

    }

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

// CIMPSSAPSecurer::GetPwdKeyL()

// Generates new the encryption key

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

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

void CIMPSSAPSecurer::GetPwdKeyL( TPtr8& aKey )

    {

    // Copy the defined key

    aKey.Copy( KSAPPwdDefinedKey );

    // Fetch the IMEI

    HBufC8* imeiBuf = HBufC8::NewLC( RMobilePhone::KPhoneSerialNumberSize );

    TPtr8 imeiPtr = imeiBuf->Des();

    FetchIMEI( imeiPtr );

    // XOR defined key with IMEI

    TText8* character = ( TText8* ) aKey.Ptr();

    TText8* characterEnd = aKey.Length() + ( TText8* ) aKey.Ptr();

    TText8 asNumber;

    const TInt imeiLen = imeiPtr.Length();

    TInt encryptCharIndex = 0;

    for ( ; character < characterEnd; character++ )

        {

        asNumber = *character;

        TInt imeiIndex( encryptCharIndex % imeiLen );

        asNumber ^= imeiPtr[ imeiIndex ];

        *character = asNumber;

        encryptCharIndex++;

        }

    CleanupStack::PopAndDestroy( imeiBuf );

    }

// End of File