/*

* Copyright (c) 2007 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 class CAkaIsaInterface

*

*/

// INCLUDE FILES

#include <e32math.h>

#include <etelmmerr.h>

#include <mmtsy_names.h>            //TSY and Phone name

#include <hash.h>

#include <implementationproxy.h>    //for ecom

#include "GBAAkaIsa.h"

#include "GBALogger.h"

#include "GbaCommon.h"

//Constants

const TInt KMaxBufferSize = 256;

const TInt KNetworkIdLength2 = 2;

const TInt KNetworkIdLength3 = 3;

const TInt KIntegerConstant4 = 4;

const TInt KIntegerConstant16 = 16;

const TInt KIntegerConstant32 = 32;

_LIT8( KAT, "@" );

_LIT8( KIMSMNC, "ims.mnc" );

_LIT8( KIMSMNC0, "ims.mnc0" );

_LIT8( KBSFMNC, "bsf.mnc" ); 

_LIT8( KBSFMNC0, "bsf.mnc0" );     

_LIT8( KMCC,".mcc");        

_LIT8( KPUB3GPPORG, ".pub.3gppnetwork.org");

_LIT8( K3GPPORG, ".3gppnetwork.org");

_LIT8( K3GPPGBARES, "3gpp-gba-res");

_LIT8( K3GPPGBAKS, "3gpp-gba-ks");

_LIT8( KGBAME, "gba-me");

#ifdef __WINS__

_LIT8( KWINTESTID, "test@pub.3gpp.org");

#endif

static MUICCInterface* NewFunctionL();

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

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

// MUICCInterface* NewFunctionL()

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

//

MUICCInterface* NewFunctionL()

    {

    GBA_TRACE_DEBUG(("MUICCInterface* NewFunctionL"));

    MUICCInterface* UICCInterface = NULL;

    UICCInterface = CAkaIsaInterface::NewL();

    return UICCInterface;

    }

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

// TImplementationProxy ImplementationTable[] 

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

//

const TImplementationProxy ImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY(GBA_UICC_INTERFACE_IMPLE, NewFunctionL)

    };

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

// TImplementationProxy* ImplementationGroupProxy()

// This function is needed by ECom and is the only one exported function

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

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

    {

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return (ImplementationTable);

    }

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

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

// CAkaIsaInterface::CAkaIsaInterface()

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

//

CAkaIsaInterface::CAkaIsaInterface():iCardInterface( ENoInterface )   

    {

    }

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

// CAkaIsaInterface::NewL()

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

//

MUICCInterface* CAkaIsaInterface::NewL()

    {

    GBA_TRACE_DEBUG(("Constructing: CAkaIsaInterface"));

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    GBA_TRACE_DEBUG(("Construction complete: CAkaIsaInterface"));

    return self;

    }

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

// CAkaIsaInterface::NewL()

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

//

void CAkaIsaInterface::ConstructL()

    {

    GBA_TRACE_BEGIN();

    //Connect to ETel server

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

    //Load phone module

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

    //open phone

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

    //open custom api

    User::LeaveIfError( iCustomAPI.Open(iPhone) );

    // check card interface, initialize iCardInterface

    QueryCardInterfaceL();

    GBA_TRACE_END();

    }

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

// CAkaIsaInterface::~CAkaIsaInterface()

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

//

CAkaIsaInterface::~CAkaIsaInterface()

    {

    GBA_TRACE_BEGIN();

    //Close all created resources 

    iCustomAPI.Close(); 

    iPhone.Close();

    iEtelServer.Close();

    GBA_TRACE_END();

    }

void CAkaIsaInterface::QueryIdentityL( TDes8& aIdentity ) 

    {

    #ifdef __WINS__

    aIdentity.Copy(KWINTESTID);

    return;

    #endif

    GBA_TRACE_BEGIN();

    GBA_TRACE_DEBUG(("QueryIdentity is starting..."));

    TUint32 caps = 0;

    GBA_TRACE_DEBUG(("Phone is open now doing the actual query..."));

    // Get capability

    User::LeaveIfError( iPhone.GetIdentityCaps( caps ) );

    if ( caps & (RMobilePhone::KCapsGetSubscriberId))

        {

        RMobilePhone::TMobilePhoneSubscriberId id;

        TRequestStatus status;

        status =  KRequestPending;

        RMobilePhone::TMobilePhoneSubscriberId iccID;

        iPhone.GetSubscriberId( status, iccID );

        User::WaitForRequest( status );

        GBA_TRACE_DEBUG_NUM(("Can't get IMSI, error = %d"), status.Int() );

        User::LeaveIfError( status.Int() );

        GBA_TRACE_DEBUG(("id="));

        GBA_TRACE_DEBUG_DESC(iccID);

        aIdentity.Zero();

        aIdentity.Copy(iccID);

        // derive the ending part

        // get the mobile network name MNC and country code MCC

        //Make IMPI 

        RMobilePhone::TMobilePhoneNetworkInfoV1 info;

        TPckg<RMobilePhone::TMobilePhoneNetworkInfoV1> netInfoPckg(info);

        status =  KRequestPending;

        iPhone.GetHomeNetwork(status, netInfoPckg);

        User::WaitForRequest( status );

        GBA_TRACE_DEBUG_NUM(("Can't get network name, error = %d"), status.Int() );

        User::LeaveIfError( status.Int() );

        // append the "<IMSI>@ims.mnc<MNC>.mcc<MCC>.3gppnetwork.org"

        aIdentity.Append( KAT );

        if ( info.iNetworkId.Length() == KNetworkIdLength2 )

            {

            //add one more zero if only 2 digits

            aIdentity.Append( KIMSMNC0 );

            }

        if ( info.iNetworkId.Length() == KNetworkIdLength3 )

            {

            aIdentity.Append( KIMSMNC ); 

            }

        aIdentity.Append( info.iNetworkId );

        aIdentity.Append( KMCC );        

        aIdentity.Append( info.iCountryCode );

        aIdentity.Append( K3GPPORG );

        GBA_TRACE_DEBUG(("aIdentity="));

        GBA_TRACE_DEBUG_DESC(aIdentity);

        }

    else

        {

        aIdentity.Copy(_L8(""));

        }

    GBA_TRACE_END();

    }

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

// CAkaIsaInterface::QueryAuthenticationGBAUL

// If the GBA_U available, pass RAND and AUTN to smart card via custom API

// otherwise use RMobilePhone instead

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

TBool CAkaIsaInterface::QueryAuthenticationGBAUL(   const TDesC8& aNonce,

                                                    TDes8& aResponse,

                                                    TDes8& aResync ) 

    {

    GBA_TRACE_BEGIN();

    TBool keys_available = ETrue;

    //creat buffer to carry the input and output value

    RMmCustomAPI::TSimAuthenticationGbaBootstrap gbadata;

    RMmCustomAPI::TGbaBootstrapDataPckg gbabuf( gbadata ); 

    //Copy input data, RAND and AUTN

    gbadata.iRandomParameters.Copy(aNonce.Ptr(),KAKA_RAND_LENGTH);

    gbadata.iAUTN.Copy(aNonce.Ptr()+KAKA_RAND_LENGTH,KAKA_RAND_LENGTH);

    //call the API to get the RES 

    TRequestStatus status;

    status =  KRequestPending;

    GBA_TRACE_DEBUG(("Send Authentication request to card"));

    iCustomAPI.GetWlanSimAuthenticationData( status, gbabuf );

    GBA_TRACE_DEBUG(("Wait for result..."));

    User::WaitForRequest( status );

    GBA_TRACE_DEBUG_NUM(("Authentication is Done, err = %d"),status.Int() );

    if(status == KErrNone)

        {

        aResponse.Copy(gbadata.iRES);

        GBA_TRACE_DEBUG_BINARY(gbadata.iRES);

        }

    else

        {

        keys_available = EFalse;

        if (status != KErrMMEtelSqnVerificationFailed )

            {

            User::LeaveIfError( status.Int() );

            }

        }

    if ( status == KErrMMEtelSqnVerificationFailed )

        {

        GBA_TRACE_DEBUG_NUM(("AUTS len is Done !!!, len = %d"), gbadata.iAUTS.Length() );

        GBA_TRACE_DEBUG_BINARY(gbadata.iAUTS);

        if(gbadata.iAUTS.Length() == 0)

            {

            GBA_TRACE_DEBUG(("Auts is Still zero !!!!!"));

            }

       else

            {

            GBA_TRACE_DEBUG((" before copy"));

            aResync.Copy(gbadata.iAUTS); 

            GBA_TRACE_DEBUG(("after copy auts"));

            }

        }

    GBA_TRACE_DEBUG((" Done!"));

    GBA_TRACE_END(); 

    return keys_available;

    }

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

// CAkaIsaInterface::QueryAuthentication2GL

// If the GBA_U available, pass RAND and AUTN to smart card via custom API

// otherwise use RMobilePhone instead

// run simulated aka

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

void CAkaIsaInterface::QueryAuthentication2GL(  const TDesC8& aNonce, TDes8& aResponse )

    {

    GBA_TRACE_BEGIN();

    RMmCustomAPI::TSimAuthenticationEapSim authSIMdata;

    RMmCustomAPI::TSimDataPckg authSIMBuf(authSIMdata);

    TRequestStatus status;

    status =  KRequestPending;

    authSIMdata.iRandomParameters.Copy(aNonce.Ptr(),KAKA_RAND_LENGTH);

    GBA_TRACE_DEBUG(("SIM authentication"));

    iCustomAPI.GetWlanSimAuthenticationData(status,authSIMBuf);

    User::WaitForRequest( status );

    GBA_TRACE_DEBUG_NUM(("GetWlanSimAuthenticationData return, status = %d"), status.Int() );

    User::LeaveIfError( status.Int() );

    GBA_TRACE_DEBUG(("Creating 2G authentication vector KDF(key,\"3gpp-gba-res\",sres)"));

    GBA_TRACE_DEBUG_BINARY(authSIMdata.iSRES);

    GBA_TRACE_DEBUG_BINARY(authSIMdata.iKC);

    TBuf8<KMaxBufferSize> lastSRESKC;

    // COPYING Kc twice

    GBA_TRACE_DEBUG(("Copying iKC"));

        {

        kc2.Append(  (TUint8)(authSIMdata.iKC[i]) );

        }

    GBA_TRACE_DEBUG(("Copying iKC"));

        {

        kc2.Append(  (TUint8)(authSIMdata.iKC[i]) );

        }

    GBA_TRACE_DEBUG(("appending RAND"));

    kc2.Append(aNonce.Ptr(),KAKA_RAND_LENGTH);

    GBA_TRACE_DEBUG(("K part"));

    GBA_TRACE_DEBUG_BINARY(kc2);

    // appending RAND

    lastSRESKC.Append( 0x01);

    lastSRESKC.Append(K3GPPGBARES);

    lastSRESKC.Append( 0x00);

    lastSRESKC.Append( 0x0C);

    GBA_TRACE_DEBUG(("Copying SRES"));

    for( TInt i=0; i<KIntegerConstant4; i++ )

        {

        lastSRESKC.Append( (TUint8)(authSIMdata.iSRES[i]) );

        }

    lastSRESKC.Append( 0x00);

    lastSRESKC.Append( 0x04);

    GBA_TRACE_DEBUG(("S part"));

    GBA_TRACE_DEBUG_BINARY(lastSRESKC);

    // derive response

    CMessageDigest* digest = CMessageDigestFactory::NewDigestL( CMessageDigest::ESHA256);

    CleanupStack::PushL( digest );

    CHMAC* sha256 = CHMAC::NewL(kc2, digest);

    CleanupStack::Pop( digest );

    CleanupStack::PushL( sha256 );

    TPtrC8 hash(sha256->Hash(lastSRESKC));

    GBA_TRACE_DEBUG(("resulting hash: "));

    GBA_TRACE_DEBUG_BINARY(hash);

    aResponse.Append(hash.Ptr(),KRESPONSE_2G_LENGTH);

    // KEY MATERIAL NEEDS TO BE STORED

    // CHECK 3GPP TS 3.3220 V7.5.0 (2006-09) page 54 item 7

    // The BSF shall generate key material Ks by computing Ks = KDF (key, Ks-input, "3gpp-gba-ks", SRES).

    // The B-TID value shall be also generated in format of NAI by taking the base64 encoded [12] RAND value

    // from step 3, and the BSF server name, i.e. base64encoded(RAND)@BSF_servers_domain_name.

    GBA_TRACE_DEBUG(("DERIVING THE MASTER KEY Ks"));

    TBuf8<KMaxBufferSize> hashMaterial;

    hashMaterial.Append(0x01);

    hashMaterial.Append(aNonce.Mid(KIntegerConstant32,KIntegerConstant16));

    hashMaterial.Append(0x00);

    hashMaterial.Append(0x10);

    hashMaterial.Append(K3GPPGBAKS);

    hashMaterial.Append(0x00);

    hashMaterial.Append(0x0b);

    hashMaterial.Append(authSIMdata.iSRES.Left(RMmCustomAPI::KMaxRESLength));

    hashMaterial.Append(0x00);

    hashMaterial.Append(0x04);

    GBA_TRACE_DEBUG(("key for creating the key"));

    GBA_TRACE_DEBUG_BINARY(kc2);

    GBA_TRACE_DEBUG(("hashing material for creating the key"));

    GBA_TRACE_DEBUG_BINARY(hashMaterial);

    TPtrC8 keymaterial( sha256->Hash( hashMaterial) );

    GBA_TRACE_DEBUG(("Master key Ks, !!! Remove from LOG"));

    GBA_TRACE_DEBUG_BINARY(keymaterial);

    iCKBuf.Copy(keymaterial.Left(KIntegerConstant16));

    iIKBuf.Copy(keymaterial.Mid(KIntegerConstant16,KIntegerConstant16));

    CleanupStack::PopAndDestroy( sha256 );

    GBA_TRACE_DEBUG(("Done!"));

    GBA_TRACE_END();

    }

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

// CAkaIsaInterface::QueryAuthentication3GL

// If the GBA_U available, pass RAND and AUTN to smart card via custom API

// otherwise use RMobilePhone instead

// run aka

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

TBool CAkaIsaInterface::QueryAuthentication3GL(   const TDesC8& aNonce,

                                                    TDes8& aResponse,

                                                    TDes8& aResync )

    {

    GBA_TRACE_BEGIN();

    TBool keys_available = ETrue;

    RMmCustomAPI::TSimAuthenticationEapAka authAkadata;

    RMmCustomAPI::TAkaDataPckg authAkaBuf(authAkadata);

    TRequestStatus status;

    status =  KRequestPending;

    authAkadata.iRandomParameters.Copy(aNonce.Ptr(),KAKA_RAND_LENGTH);

    authAkadata.iAUTN.Copy(aNonce.Ptr()+KAKA_RAND_LENGTH,KAKA_RAND_LENGTH);

    GBA_TRACE_DEBUG(("AKA authentication"));

    iCustomAPI.GetWlanSimAuthenticationData(status,authAkaBuf);

    User::WaitForRequest( status );

    GBA_TRACE_DEBUG_NUM(("GBA_ME:QueryAuthentication3GL: Authentication error = %d"),status.Int()  );

    if( status.Int() == KErrNone )

        {

        GBA_TRACE_DEBUG(("AKA, appending result"));

        aResponse.Copy(authAkadata.iRES);

        GBA_TRACE_DEBUG_BINARY(authAkadata.iRES);

        GBA_TRACE_DEBUG(("storing keys"));

        // store results

        iCKBuf.Copy(authAkadata.iCK);

        iIKBuf.Copy(authAkadata.iIK);

        }

    else

        {

        keys_available = EFalse;

        if (status != KErrMMEtelSqnVerificationFailed )

            {

            User::LeaveIfError( status.Int() );

            }

        }

    if ( status == KErrMMEtelSqnVerificationFailed )

        {

        GBA_TRACE_DEBUG_NUM(("GBA_ME:QueryAuthentication3GL: AUTS len is Done !!!, len = %d"), authAkadata.iAUTS.Length() );

        GBA_TRACE_DEBUG_BINARY( authAkadata.iAUTS );

        if(authAkadata.iAUTS.Length() == 0)

            {

            GBA_TRACE_DEBUG(("GBA_U:QueryAuthentication3GL: Auts is Still zero !!!!!"));

            }

        else

            {

            GBA_TRACE_DEBUG(("QueryAuthentication3GL before copy"));

            aResync.Copy(authAkadata.iAUTS);

            GBA_TRACE_DEBUG(("QueryAuthentication3GL after copy auts"));

            }

        }

    GBA_TRACE_END();

    return keys_available;

    }

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

// CAkaIsaInterface::QueryAuthenticationL

// If the GBA_U available, pass RAND and AUTN to smart card via custom API

// otherwise use RMobilePhone instead

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

TBool CAkaIsaInterface::QueryAuthenticationL(

     const TDesC8& aNonce, 

     TDes8& aResponse, 

     TDes8& aResync ) 

    {

    GBA_TRACE_BEGIN();

    GBA_TRACE_DEBUG(("aka nonce="));

    GBA_TRACE_DEBUG_BINARY(aNonce);

    // GBA_U not availiable

    if ( iCardInterface != EGBAUInterface )

        {

        GBA_TRACE_DEBUG(("QueryAuthenticationL is starting..."));

        //run aka

        if ( iCardInterface == E3GInterface )

            {

            return QueryAuthentication3GL( aNonce, aResponse, aResync );

            }

        // run simulated aka

        if ( iCardInterface == E2GInterface )

            {

            QueryAuthentication2GL( aNonce, aResponse );

            return ETrue;

            }

        return EFalse;

        }

    else

        {