/*

* Copyright (c) 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:

 *

*/

// INCLUDE FILES

#include  "cstscmdapdu.h"

#include "stsapduconstants.h"

#include "logger.h"

namespace java

{

namespace satsa

{

// CONSTANTS

//Apdu instructions

const TUint8 KSTSINSManageChannel = 0x70;

const TUint8 KSTSINSSelectFile = 0xA4;

const TUint8 KSTSINSDeactivateFile = 0x04;

const TUint8 KSTSINSActivateFile = 0x44;

const TUint8 KSTSP1SelectAID = 0x04;

const TUint8 KSTSP1SelectByFileId = 0x00;

const TUint8 KSTSP1SelectByPathFromMF = 0x08;

const TUint8 KSTSP1SelectByPathFromCurrentDF = 0x09;

const TInt KFileIdLength = 2;

//Lc byte length is one (it is not part of the mandatory header and is not

//part of the real data

const TInt KSTSHeaderAndLcLength = KSTSApduMandatoryHeaderLen + 1;

//Phone application's File Ids on the UICC card

//according to ETSI TS 102 221

_LIT8(KSTSFileIdDFTelecom, "\x7F\x10");

_LIT8(KSTSFileIdDFGSM, "\x7F\x20");

_LIT8(KSTSFileIdDFDCS1800, "\x7F\x21");

_LIT8(KSTSFileIdDFIS_41, "\x7F\x22");

_LIT8(KSTSFileIdDFFP_CTS, "\x7F\x23");

_LIT8(KSTSFileIdDFTIA_EIA_136, "\x7F\x24");

_LIT8(KSTSFileIdDFTIA_EIA_95, "\x7F\x25");

_LIT8(KSTSFileIdDFRFU1, "\x7F\x26"); //Reserved For Future Use

_LIT8(KSTSFileIdDFRFU2, "\x7F\x27");

_LIT8(KSTSFileIdDFRFU3, "\x7F\x28");

_LIT8(KSTSFileIdDFRFU4, "\x7F\x29");

_LIT8(KSTSFileIdDFRFU5, "\x7F\x2A");

_LIT8(KSTSFileIdDFRFU6, "\x7F\x2B");

_LIT8(KSTSFileIdDFRFU7, "\x7F\x2C");

_LIT8(KSTSFileIdDFRFU8, "\x7F\x2D");

_LIT8(KSTSFileIdDFRFU9, "\x7F\x2E");

_LIT8(KSTSFileIdDFRFU10, "\x7F\x2F");

_LIT8(KSTSFileIdDFPDC, "\x7F\x80");

_LIT8(KSTSFileIdDFTETRA, "\x7F\x90");

_LIT8(KSTSFileIdDFIDEN, "\x7F\x31");

//PKCS#15 DF files

//should read from EF(DIR) file (hardcoded at the moment)

_LIT8(KSTSFileIdDFPKCS15Gemplus, "\x7F\x50");

_LIT8(KSTSFileIdDFPKCS15Orga, "\x50\x15");

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

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

// CSTSCmdApdu::CSTSCmdApdu

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

// might leave.

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

//

CSTSCmdApdu::CSTSCmdApdu()

{

}

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

// CSTSCmdApdu::NewLC

// Two-phased constructor.

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

//

CSTSCmdApdu* CSTSCmdApdu::NewLC(TDesC8& aApduBytes,

                                CSTSApdu::TSTSApduStandard aStandard)

{

    LOG(ESATSA, EInfo, "+ CSTSCmdApdu::NewLC");

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

    CleanupStack::PushL(self);

    self->ConstructL(aApduBytes, aStandard);

    LOG(ESATSA, EInfo, "-- CSTSCmdApdu::NewLC");

    return self;

}

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

// CSTSCmdApdu::NewL

// Two-phased constructor.

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

//

CSTSCmdApdu* CSTSCmdApdu::NewL(TDesC8& aApduBytes,

                               CSTSApdu::TSTSApduStandard aStandard)

{

    LOG(ESATSA, EInfo, "+ CSTSCmdApdu::NewL() called");

    CSTSCmdApdu* self = CSTSCmdApdu::NewLC(aApduBytes, aStandard);

    CleanupStack::Pop(self);

    LOG(ESATSA, EInfo, "-- CSTSCmdApdu::NewL ");

    return self;

}

// Destructor

CSTSCmdApdu::~CSTSCmdApdu()

{

    delete iApduData;

}

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

// CSTSCmdApdu::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSTSCmdApdu::ConstructL(TDesC8& aApduBytes,

                             CSTSApdu::TSTSApduStandard aStandard)

{

    LOG(ESATSA, EInfo, "+ CSTSCmdApdu::ConstructL");

    iApduData = NULL;

    iApduData = CSTSApdu::NewL(aApduBytes, aStandard);

    if (!iApduData)

    {

        ELOG(ESATSA, "CSTSCmdApdu::ConstructL: failed to create iApduData");

    }

    LOG(ESATSA, EInfo, "-- CSTSCmdApdu::ConstructL");

}

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

// CSTSCmdApdu::CheckL

// Checks apdu data and leaves with proper error code

// Checking is done according to JSR177 design document.

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

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

void CSTSCmdApdu::CheckL(TInt aUsedChannel) const

{

    LOG(ESATSA, EInfo, "+ CSTSCmdApdu::CheckL");

    CheckApduLengthL();

    TInt8 cla = ApduByte(ESTSCLA);

    TInt8 ins = ApduByte(ESTSINS);

    //contains a card selection APDU

    if ((ins == (TInt8) KSTSINSSelectFile) && (iApduData->ApduPtr()[ESTSP1]

            == KSTSP1SelectAID))

    {

        ELOG(ESATSA, "CSTSCmdApdu::CheckL:  Select AID: IllegalArgument");

        User::Leave(KSTSErrIllegalArgument + KSTSErrIASelectApp);

    }

    //contains a MANAGE CHANNEL command APDU

    if (((cla >= 0x00) || (cla <= 0x0F)) //b1 can be "anything", b2 must be 0

            && (ins == KSTSINSManageChannel))

    {

        ELOG(ESATSA, "CSTSCmdApdu::CheckL: Manage Channel: IllegalArgument");

        User::Leave(KSTSErrIllegalArgument + KSTSErrIAManageChannel);

    }

    //if the channel associated with the connection object is non-zero

    //and the CLA byte has a value other than 0x0X, 0x8X, 0x9X or 0xAX

    if (aUsedChannel != 0)

    {

        TUint8 claMask = 0xF0; //11110000

        TUint8 claLeft = (TUint8)(cla & claMask);  //ignore low order bits

        if ((claLeft != 0x00) && //The coding is according to ISO7816-4

                (claLeft != 0x90) && (claLeft != 0xA0) && //Coded as ISO7816-4 unless stated otherwise

                (claLeft != 0x80)) //Structured as ISO/IEC 7816-4 [12], coding

            //and meaning is defined in ETSI TS 102 221

        {

            ELOG(ESATSA, "CSTSCmdApdu::CheckL: aUsedChannel: IllegalArgument");

            User::Leave(KSTSErrIllegalArgument + KSTSErrIAOtherCLA);

        }

    }

    CheckPhoneAppSelectionL();

    LOG(ESATSA, EInfo, "-- CSTSCmdApdu::CheckL");

}

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

// CSTSCmdApdu::ApduBytes

//

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

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

TPtr8& CSTSCmdApdu::ApduBytes() const

{

    return iApduData->ApduPtr();

}

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

// CSTSCmdApdu::CheckApduLengthL

// Leaves if apdu length is not atleast same than standard apdu header length

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

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

void CSTSCmdApdu::CheckApduLengthL() const

{

    LOG(ESATSA, EInfo, "+ CSTSCmdApdu::CheckApduLengthL");

    //too short apdu

    TInt apduLength = iApduData->ApduPtr().Length();

    if (apduLength < KSTSApduMandatoryHeaderLen)

    {

        ELOG1(ESATSA, "Too short: KSTSErrIllegalArgument. apdulength is %d",

              apduLength);

        User::Leave(KSTSErrIllegalArgument + KSTSErrIAMalformedAPDU);

    }

    //if data length is not same than Lc

    //note: if there is no data, P3 means Le

    if (apduLength > KSTSHeaderAndLcLength + 1) // must be data or Le

    {

        TInt lengthAfterHeaderAndLc = apduLength - KSTSHeaderAndLcLength;

        TInt lc = ApduByte(ESTSLc);

        ILOG2(ESATSA, "Data length = %d, lc = %d",

              lengthAfterHeaderAndLc, lc);

        if ((lengthAfterHeaderAndLc != lc)

                && (lengthAfterHeaderAndLc - lc != 1)) //there can be one Le byte

        {

            ELOG(ESATSA, "Incorrect data length: KSTSErrIllegalArgument");

            User::Leave(KSTSErrIllegalArgument + KSTSErrIAMalformedAPDU);

        }

    }

    LOG(ESATSA, EInfo, "-- CSTSCmdApdu::CheckApduLengthL");

}

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

// CSTSCmdApdu::SetChannel

// Adds gived channel to command APDU message's CLA byte

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

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

void CSTSCmdApdu::SetChannel(TInt aChannel)

{

    // mask for getting cla bytes six first bits

    TUint8 claMask = 0xFC; //11111100

    TUint8 channel = (TUint8) aChannel;

    TUint8 cla = ApduByte(ESTSCLA);

    // take cla byte's six first bits

    cla = (TUint8)(cla & claMask);

    // add channel to cla byte's two last bits

    cla = (TUint8)(cla | channel);

    SetApduByte(cla, ESTSCLA);

}

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

// CSTSCmdApdu::SetHeader

//

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

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

void CSTSCmdApdu::SetHeader(TUint8 aCla, TUint8 aIns, TUint8 aP1, TUint8 aP2)

{

    SetApduByte(aCla, ESTSCLA);

    SetApduByte(aIns, ESTSINS);

    SetApduByte(aP1, ESTSP1);

    SetApduByte(aP2, ESTSP2);

}

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

// CSTSCmdApdu::Header

//

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

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

const TDesC8& CSTSCmdApdu::Header()

{

    iHeaderPtr.Set(iApduData->ApduPtr().Mid(0, KSTSApduMandatoryHeaderLen));

    return iHeaderPtr;

}

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

// CSTSCmdApdu::AppendDatabytesL

//

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

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

void CSTSCmdApdu::AppendDatabytesL(const TDesC8& aDataBytes)

{

    TInt dataLength = aDataBytes.Length();

    //headerlength + Lc + Data

    TInt maxLength = KSTSApduMandatoryHeaderLen + 1 + dataLength;

    iApduData->ReAllocL(maxLength);

    iApduData->ApduPtr().Append((TUint8) dataLength); //Le

    iApduData->ApduPtr().Append(aDataBytes); //data

}

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

// CSTSCmdApdu::SetLe

//

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

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

void CSTSCmdApdu::SetLe(TUint8 aLe)

{

    TInt lenght = iApduData->ApduPtr().Length();

    //last byte is Le

    iApduData->ApduPtr()[lenght - 1] = aLe;

}

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

// CSTSCmdApdu::ApduByte

//

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

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

TUint8 CSTSCmdApdu::ApduByte(TSTSApduByteType aByteType) const

{

    return iApduData->ApduPtr()[aByteType];

}

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

// CSTSCmdApdu::SetApduByte

//

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

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

void CSTSCmdApdu::SetApduByte(TUint8 aByte, TSTSApduByteType aByteType)

{

    iApduData->ApduPtr()[aByteType] = aByte;

}

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

// CSTSCmdApdu::CheckPhoneAppSelectionL

// Checks if used apdu leads to selection of application/file or

// other restricted file which is not allowed to be selected. Leaves with

// security leave if it is true.

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

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

void CSTSCmdApdu::CheckPhoneAppSelectionL() const

{

    LOG(ESATSA, EInfo, "+ CSTSCmdApdu::CheckPhoneAppSelectionL, called");

    TInt dataLength = iApduData->ApduPtr().Length() - KSTSHeaderAndLcLength;

    LOG1(ESATSA, EInfo, "CSTSCmdApdu::CheckPhoneAppSelectionL, dataLength: %d", dataLength);

    //Checks does apdu lead to file selection

    if (IsProperFileSelectionApdu(dataLength))

    {

        LOG(ESATSA, EInfo, "is file selection apdu");

        //take data part from the apdu

        const TPtrC8 data(iApduData->ApduPtr().Ptr() + KSTSHeaderAndLcLength,

                          dataLength);

        //check that possible file id does not contain forbidden file id

        CheckFileIdL(data);

        //check that possible path does not contain forbidden file ids

        CheckPathL(data);

    }

}

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

// CSTSCmdApdu::CheckIllegalFileIdL

// Checks is file id forbidden or not. Leaves if it is forbidden.

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

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

void CSTSCmdApdu::CheckIllegalFileIdL(const TDesC8& aFileId) const

{

    LOG(ESATSA, EInfo, "CSTSCmdApdu::CheckIllegalFileIdL, called");

    //file id length should be 2

    if ((aFileId == KSTSFileIdDFTelecom()) || (aFileId == KSTSFileIdDFGSM())

            || (aFileId == KSTSFileIdDFDCS1800()) || (aFileId

                    == KSTSFileIdDFIS_41()) || (aFileId == KSTSFileIdDFFP_CTS())

            || (aFileId == KSTSFileIdDFTIA_EIA_136()) || (aFileId

                    == KSTSFileIdDFTIA_EIA_95()) || (aFileId == KSTSFileIdDFRFU1())

            || (aFileId == KSTSFileIdDFRFU2()) || (aFileId

                                                   == KSTSFileIdDFRFU3()) || (aFileId == KSTSFileIdDFRFU4())

            || (aFileId == KSTSFileIdDFRFU5()) || (aFileId

                                                   == KSTSFileIdDFRFU6()) || (aFileId == KSTSFileIdDFRFU7())

            || (aFileId == KSTSFileIdDFRFU8()) || (aFileId

                                                   == KSTSFileIdDFRFU9()) || (aFileId == KSTSFileIdDFRFU10())

            || (aFileId == KSTSFileIdDFPDC()) || (aFileId

                                                  == KSTSFileIdDFTETRA()) || (aFileId == KSTSFileIdDFIDEN())

            || (aFileId == KSTSFileIdDFPKCS15Gemplus()) || (aFileId

                    == KSTSFileIdDFPKCS15Orga()))

    {

        ELOG(ESATSA, "CSTSCmdApdu::CheckIllegalFileIdL, Is illegal!");

        User::Leave(KSTSErrSecurity + KSTSErrSECIllegalFileID);

    }

}

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

// CSTSCmdApdu::IsProperFileSelectionApdu

// Checks does apdu lead to file selection. SELECT FILE, DEACTIVATE FILE and

// ACTIVATE FILE apdu will lead to file selection in case of successful

// execution of the command,

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

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

TBool CSTSCmdApdu::IsProperFileSelectionApdu(TInt aDataLength) const

{

    LOG(ESATSA, EInfo, "CSTSCmdApdu::IsProperFileSelectionApdu, called");

    TBool returnValue = EFalse;

    //Check is it SELECT FILE apdu and contains data field

    if (ApduByte(ESTSINS) == KSTSINSSelectFile && aDataLength > 0)

    {

        returnValue = ETrue;

    }

    //Check is it DEACTIVATE FILE apdu and contains data field

    else if (ApduByte(ESTSINS) == KSTSINSDeactivateFile && aDataLength > 0)

    {

        returnValue = ETrue;

    }

    //Check is it ACTIVATE apdu and contains data field

    else if (ApduByte(ESTSINS) == KSTSINSActivateFile && aDataLength > 0)

    {

        returnValue = ETrue;

    }

    return returnValue;

}

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

// CSTSCmdApdu::CheckPathL

// Checks is there proper path and does it contain illegal file ids.

// Leaves if there is illegal file ids.

// Note that apdu must be SELECT FILE, DEACTIVATE FILE or ACTIVATE FILE apdu.

// That can be checked with IsProperFileSelectionApdu method. P1 byte of those

// apdus are the same in select by path from MF and select by path from current

// DF case.

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

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

void CSTSCmdApdu::CheckPathL(const TDesC8& aData) const

{

    TUint8 p1 = ApduByte(ESTSP1);

    TInt dataLength = aData.Length();

    //check that path does not contain forbidden ids

    if ((p1 == KSTSP1SelectByPathFromMF) || (p1

            == KSTSP1SelectByPathFromCurrentDF))

    {

        LOG(ESATSA, EInfo, "CSTSCmdApdu::CheckPathL, is Path");

        TInt remainder;

        TInt tmpDataLength = dataLength;

        I64DIVMOD(tmpDataLength, KFileIdLength, remainder);

        //if data field does not contain concatenation of file ids

        if (remainder != 0)

        {

            ELOG(ESATSA, "CSTSCmdApdu::CheckPathL, Leave!!");

            User::Leave(KSTSErrIllegalArgument + KSTSErrIAMalformedAPDU);

        }

        else

        {

            LOG(ESATSA, EInfo, "CSTSCmdApdu::CheckPathL, go through in loop");

            //go through in loop all file ids in path

            for (TInt i = 0; i < dataLength; i += KFileIdLength)

            {

                TPtrC8 currentFid(aData.Ptr() + i, KFileIdLength);

                CheckIllegalFileIdL(currentFid);

            }

        }

    }

    //else no actions

}

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

// CSTSCmdApdu::CheckFileIdL

// Checks is there proper file id and is it illegal. Leaves if there is illegal

// file id.

// Note that apdu must be SELECT FILE, DEACTIVATE FILE or ACTIVATE FILE apdu.

// That can be checked with IsProperFileSelectionApdu method. INS byte of those

// apdus are the same in select by file id case.

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

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

void CSTSCmdApdu::CheckFileIdL(const TDesC8& aData) const

{

    TUint8 p1 = ApduByte(ESTSP1);

    TInt dataLength = aData.Length();

    //Check is file id used

    if (p1 == KSTSP1SelectByFileId)

    {

        //if data field does not contain file id, leave

        if (dataLength != KFileIdLength)

        {

            ELOG(ESATSA, "CSTSCmdApdu::CheckFileIdL, Leave !!");

            User::Leave(KSTSErrIllegalArgument + KSTSErrIAMalformedAPDU);

        }

        else

        {

            //check that file id is not forbidden

            CheckIllegalFileIdL(aData);

        }

    }

    //else no actions

}

} // namespace satsa

} // namespace java

//  End of File