/*

* Copyright (c) 2004-2006 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:  PnpUtil implementation

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <e32math.h>

#include <mmtsy_names.h>

#include <asymmetric.h>         // For RInteger

#include <3des.h>               // For C3DES

#include <centralrepository.h>  // link against centralrepository.lib

#include "PnpUtilImpl.h"

#include "PnpUtilLogger.h"

#include "PnpUtilPrivateCRKeys.h" // Central repository keys

// CONSTANTS

const TInt KMaxModulusLength = 300;

const TInt KMaxPublicExponentLength = 10;

// Default token validity time

const TInt KTokenValidityTime = 600;

const TInt KTokenLength = 4;

// C3DESEncryptor and C3DESDecryptor require the buffer to be more than 4 characters

// (8 characters seems to be enough)

const TInt KTokenLengthDuringStorage = 8;

const TInt KEncryptionKeyLength = 24;

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

// CPnpUtilImpl::ConstructL

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

//

void CPnpUtilImpl::ConstructL()

    {

    LOGSTRING( "Enter to CPnpUtilImpl::ConstructL()" );

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

    LOGSTRING( "CPnpUtilImpl::ConstructL() 2" );

    User::LeaveIfError( iServer.LoadPhoneModule( KMmTsyModuleName ) );

    LOGSTRING( "CPnpUtilImpl::ConstructL() 3" );

    User::LeaveIfError( iPhone.Open( iServer, KMmTsyPhoneName ) );

    LOGSTRING( "CPnpUtilImpl::ConstructL() 4" );

    User::LeaveIfError( iPhone.Initialise() );

    LOGSTRING( "CPnpUtilImpl::ConstructL() 5" );

    iRepository = CRepository::NewL( KCRUidPnpUtil );

    TBuf8<KEncryptionKeyLength> encryptkey;

    CreateEncryptionKeyL(encryptkey);

#ifndef __WINS__ // calling C3DESEncryptor::NewL crashes emulator

    iEncryptor = C3DESEncryptor::NewL( encryptkey );

    iDecryptor = C3DESDecryptor::NewL( encryptkey );

#endif 

    LOGSTRING( "Exit from CPnpUtilImpl::ConstructL()" );

    }

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

// CPnpUtilImpl::NewLC

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

//

EXPORT_C CPnpUtilImpl* CPnpUtilImpl::NewLC()

    {

    LOGSTRING("CPnpUtilImpl::NewLC");

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CPnpUtilImpl::CPnpUtilImpl

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

//

CPnpUtilImpl::CPnpUtilImpl()

    {

    LOGSTRING("CPnpUtilImpl()");

    }

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

// CPnpUtilImpl::~CPnpUtilImpl

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

//

EXPORT_C CPnpUtilImpl::~CPnpUtilImpl()

    {

    LOGSTRING( "~CPnpUtilImpl" );

    delete iRepository;

    iPhone.Close();

    iServer.Close();

#ifndef __WINS__

    delete iEncryptor;

    delete iDecryptor;

#endif

    LOGSTRING( "~CPnpUtilImpl - done" );

    }

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

// CPnpUtilImpl::Version

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

//

EXPORT_C TInt CPnpUtilImpl::Version( TDes& aVersion )

    {

    LOGSTRING( "CPnpUtilImpl::Version" );

    // There is now a separate dll for HDC so there is no need to

    // read the version string from a database, we may use

    // a hard-coded value instead.

    _LIT( KTempVersion, "NPnP-MSS60-1.01" );

    // Max length is KMaxVersionStringLength

    if( KTempVersion().Length() > aVersion.MaxLength() )

        {

        return KErrArgument;

        }

    aVersion.Copy( KTempVersion );

    return KErrNone;

    }

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

// CPnpUtilImpl::CreateNewToken

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

//

EXPORT_C TInt CPnpUtilImpl::CreateNewToken(TUint32 aTimeout, TInt& aToken)

    {

    LOGSTRING("CPnpUtilImpl::CreateNewToken");

    TInt value(0);

    // Get current time

    TTime t;

    t.HomeTime();

    TInt64 time = t.Int64();

    // Create timeout

    if( aTimeout > 9999 )

        {

        LOGSTRING("too long timeout - KErrArgument");

        return KErrArgument;

        }

    // Deadline = currenttime + (atimeout * 1000000)

    TInt64 deadline = time + TInt64((TInt)aTimeout) * TInt64(1000000);

    TBuf<21> num;    // 20 is max length for 64 bit integer (radix 10)

    num.AppendNum(deadline);

    LOGSTRING("WriteDeadline");

    LOGTEXT(num);

    // Store deadline

    TInt result = iRepository->Set( KPnPUtilDeadline, num );

    if( result != KErrNone )

        {

        LOGSTRING2("Storing deadline failed: %i", result);

        return result;

        }

    value = Math::Rand(time);

    value %= (9999 - 1001);

    value += 1001;

    LOGSTRING2( "New Token: %i", value );

    // KTokenLength is too small for the buffer length because C3DESEncryptor/C3DESDecryptor

    // cannot handle small buffers

    TBuf8<KTokenLengthDuringStorage> tokenBuf;

    tokenBuf.AppendNum( value );

    tokenBuf.AppendNum( 1234 );

    // Encrypt

#ifndef __WINS__

    iEncryptor->Transform( tokenBuf );

#endif

    // Save token

    result = iRepository->Set( KPnPUtilToken, tokenBuf );

    aToken = value;

    LOGSTRING("CPnpUtilImpl::CreateNewToken - done");

    return result;

    }

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

// CPnpUtilImpl::GetTokenValidityTime

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

//

EXPORT_C TInt CPnpUtilImpl::GetTokenValidityTime()

    {

    LOGSTRING("CPnpUtilImpl::GetTokenValidityTime");

    return KTokenValidityTime;

    }

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

// CPnpUtilImpl::GetTokenValue

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

//

EXPORT_C TInt CPnpUtilImpl::GetTokenValue(TInt& aToken)

    {

    LOGSTRING("Enter CPnpUtilImpl::GetTokenValue");

    // Check deadline

    TBuf<21> num;

    LOGSTRING("ReadDeadline");

    TInt result = iRepository->Get( KPnPUtilDeadline, num );

    if( result != KErrNone )    

        {

        return KErrCorrupt;

        }

    LOGTEXT(num);

    TLex l(num);

    TInt64 deadline(0);

    if( l.Val(deadline)!= KErrNone )

        {

        return KErrCorrupt;

        }

    // Check validity time

    TTime t;

    t.HomeTime();

    if( t > deadline )

        {

        TTimeIntervalSeconds seconds(0);

        t.SecondsFrom( deadline, seconds );

        LOGSTRING2( "Token validity expired: %is ago", seconds.Int() );

        return KErrTimedOut;

        }

    LOGSTRING("Token not expired");

    // Get token

    // KTokenLength is too small for the buffer length because C3DESEncryptor/C3DESDecryptor

    // cannot handle small buffers

    TBuf8<KTokenLengthDuringStorage> tokenBuf;

    result = iRepository->Get( KPnPUtilToken, tokenBuf );

    if( result != KErrNone )

        {

        LOGSTRING2( "Error %i when trying to read token value", result );

        return result;

        }

    LOGSTRING("Tokenbuf:");

    LOGTEXT( tokenBuf );

#ifndef __WINS__

    iDecryptor->Transform( tokenBuf );

#endif

    TInt token(0);

    TLex8 parser( tokenBuf.Left( KTokenLength ) );

    parser.Val( token );

    if( token < 1 || token > 9999)

        {

        return KErrCorrupt;

        }

    LOGSTRING("Token OK");

    LOGSTRING2("Token: %i", token);

    aToken = token;

    return KErrNone;

    }

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

// CPnpUtilImpl::CreateNewNonceL

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

//

EXPORT_C void CPnpUtilImpl::CreateNewNonceL( const TUint /*aTimeOut*/, TDes8& aNonce )

    {

    LOGSTRING("CPnpUtilImpl::CreateNewNonceL");

    if( aNonce.MaxLength() < KNonceLength )

        {

        User::Leave( KErrArgument );

        }

    TBuf8<KNonceLength> buffer;

    TTime time;

    time.HomeTime();

    TInt64 seed = time.Int64();

    for( TInt i(0); i < KNonceLength; i++ )

        {

        TChar character( RandomCharacter( seed ) );

        buffer.Append( character );

        }

    LOGSTRING("New Nonce:");

    LOGTEXT( buffer );

    aNonce.Copy( buffer );

    // Encrypt

#ifndef __WINS__

    iEncryptor->Transform( buffer );

#endif

    // Save the nonce

    User::LeaveIfError( iRepository->Set( KPnPUtilNonce, buffer ) );

    LOGSTRING("CPnpUtilImpl::CreateNewNonceL - done");

    }

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

// CPnpUtilImpl::GetNonceValidityTimeL

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

//

EXPORT_C TInt CPnpUtilImpl::GetNonceValidityTimeL()

    {

    // Not used

    User::Leave( KErrNotSupported );

    return KErrNone;

    }

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

// CPnpUtilImpl::GetNonceL

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

//

EXPORT_C void CPnpUtilImpl::GetNonceL( TDes8& aNonce )

    {

    LOGSTRING("CPnpUtilImpl::GetNonceL");

    if( aNonce.MaxLength() < KNonceLength )

        {

        User::Leave( KErrArgument );

        }

    TBuf8<KNonceLength> buffer;

    User::LeaveIfError( iRepository->Get( KPnPUtilNonce, buffer) );

    // Decrypt

#ifndef __WINS__

    if( buffer.Length() > 0 )

    	{

    	LOGTEXT( buffer );

    	iDecryptor->Transform( buffer );

    	}

#endif

    LOGSTRING("Nonce:");

    LOGTEXT( buffer );

    aNonce.Copy( buffer );

    LOGSTRING("CPnpUtilImpl::GetNonceL - done");

    }

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

// CPnpUtilImpl::RandomCharacter

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

//

TUint CPnpUtilImpl::RandomCharacter( TInt64& aSeed )

    {

    // Create random number value for token

    TInt value = Math::Rand( aSeed );

    if( value < 0 )

        {

        value = -value;

        }

    value %= 61; // [0,61]

    value += 48; // [48,109]

    // split the range to ranges [48,57],[65,90] and [97,122]

    // that is: the ascii codes for numbers from 0 to 9,

    // capital alphabets from A to Z and alphabets from a to z

    if( value > 57 )

        {

        value += 8; // [65,90]

        if( value > 90 )

            {

            value += 6; // [97,122]

            }

        }

    return value;

    }

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

// CPnpUtilImpl::GetKeyInfoL

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

//

EXPORT_C void CPnpUtilImpl::GetKeyInfoL( TDes8& aKeyInfo )

    {

    LOGSTRING("CPnpUtilImpl::GetKeyInfoL");

    if( aKeyInfo.MaxLength() < KMaxKeyInfoLength )

        {

        User::Leave( KErrArgument );

        }

    // read keyinfo from cenrep

    TBuf<KMaxKeyInfoLength> buffer;

    User::LeaveIfError( iRepository->Get( KPnPUtilKeyInfo, buffer) );

    aKeyInfo.Copy( buffer );

    LOGSTRING("CPnpUtilImpl::GetKeyInfoL - done");

    }

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

// CPnpUtilImpl::VerifySignatureL

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

//

EXPORT_C TBool CPnpUtilImpl::VerifySignatureL(

        const TDesC8& aDigestValue, const TDesC8& aSignatureValue,

        const TDesC8& aData, const TDesC8& aNonce )

    {

    LOGSTRING( "CPnpUtilImpl::VerifySignatureL" );

    LOGTEXT( aDigestValue );

    HBufC8* sendersDigest = DecodeBase64LC( aDigestValue );

    LOGSTRING( "senders digest:" );

    LogAsASCIIHexL( *sendersDigest );

    HBufC8* sendersSignature = DecodeBase64LC( aSignatureValue );

    LOGSTRING( "senders signature:" );

    LogAsASCIIHexL( *sendersSignature );

    // Read Modulus and PublicExponent from Cenrep

    LOGSTRING( "Read Modulus and PublicExponent from Cenrep" );

    TBuf<KMaxModulusLength> bufferMod;

    TBuf<KMaxPublicExponentLength> bufferExp;

    User::LeaveIfError( iRepository->Get( KPnPUtilModulus, bufferMod) );

    User::LeaveIfError( iRepository->Get( KPnPUtilPublicExponent, bufferExp) );

    TBuf8<KMaxModulusLength> bufferMod8;

    TBuf8<KMaxPublicExponentLength> bufferExp8;

    bufferMod8.Copy( bufferMod );

    bufferExp8.Copy( bufferExp );

    LOGSTRING( "Pack modulus and exponent" );

    // Look for (lousy/faulty) documentation for RInteger from the 2.1 SDK

    HBufC8* modulusBuf = PackLC( bufferMod8 );

    HBufC8* exponentBuf = PackLC( bufferExp8 );

    RInteger modulus = RInteger::NewL( *modulusBuf );

    RInteger exponent = RInteger::NewL( *exponentBuf );

    CRSAPublicKey* publicKey = CRSAPublicKey::NewLC( modulus, exponent );

    CRSAPKCS1v15Verifier* rsaVerifier = CRSAPKCS1v15Verifier::NewLC( *publicKey );

    RInteger rsaSignatureInteger = RInteger::NewL( *sendersSignature );

    CRSASignature* signature = CRSASignature::NewLC( rsaSignatureInteger );

    // Verify the digest against the signature

    TBool verified = rsaVerifier->VerifyL( *sendersDigest, *signature );

    // These are not needed anymore, destroy

    CleanupStack::PopAndDestroy( signature );

    CleanupStack::PopAndDestroy( rsaVerifier );

    CleanupStack::PopAndDestroy( publicKey );

    CleanupStack::PopAndDestroy( exponentBuf );

    CleanupStack::PopAndDestroy( modulusBuf );

    CleanupStack::PopAndDestroy( sendersSignature );

    if( verified ) // Signature was verified

        {

        LOGSTRING( "Signature Verified" );

        // ...Yep, verify also digest

        verified = VerifyDigestL( *sendersDigest, aData, aNonce );

        if( verified )

            {

            LOGSTRING( "Digest Verified" );

            }

        else

            {

            LOGSTRING( "Digest NOT verified" );

            }

        }

    else

        {

        // ...Nope, do not check the digest, verify already failed anyways

        LOGSTRING( "Signature NOT verified" );

        }

    CleanupStack::PopAndDestroy( sendersDigest );

    LOGSTRING( "CPnpUtilImpl::VerifySignatureL - done" );

    return verified;

    }

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

// CPnpUtilImpl::VerifyDigestL

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

//

TBool CPnpUtilImpl::VerifyDigestL(

        const TDesC8& aSendersDigest, const TDesC8& aData, const TDesC8& aNonce )

    {

    LOGSTRING( "VerifyDigestL" );

    LOGTEXT( aData );

    LOGTEXT( aNonce );

    CSHA1* sha1 = CSHA1::NewL();

    CleanupStack::PushL( sha1 );

    HBufC8* dataToBeHashed = HBufC8::NewLC( aData.Length() + aNonce.Length() + 1 );

    TPtr8 dataToBeHashedPtr = dataToBeHashed->Des();

    _LIT8( KColon, ":" );

    dataToBeHashedPtr.Append( aNonce );

    dataToBeHashedPtr.Append( KColon );

    dataToBeHashedPtr.Append( aData );

    LOGSTRING( "nonce:data" );

    LogAsASCIIHexL( *dataToBeHashed );

    TPtrC8 hash = sha1->Final( *dataToBeHashed );

    LOGSTRING( "computed hash:" );