/*

* 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: Pkcs10 certificate request.

*

*/

#include <eikenv.h>

#include <asn1cons.h>

#include <asn1enc.h>

#include <x520ava.h>

#include "pkcs10.h"

#include "base64.h"

#include "pkidefs.h"

#include "utlcrypto.h"

EXPORT_C CPkcs10Req::CPkcs10Req()

	{

	}

//////////////////////////////////////////////////////////////////////////////

// Destructor

//////////////////////////////////////////////////////////////////////////////

EXPORT_C CPkcs10Req::~CPkcs10Req()

{

    delete iDNDerBuf;

}

//////////////////////////////////////////////////////////////////////////////

// Set distinguished name parameter, Only CommonName given

//////////////////////////////////////////////////////////////////////////////

EXPORT_C TInt CPkcs10Req::SetDistinguishedName(const TDesC8 &aDistinguishedName)

{

    TInt status = KErrNone;

    // Set distiguished name

    if(aDistinguishedName.Length() > 0)

    {

        iDistinguishedName.Set(aDistinguishedName);

        iUseExtendedDistinguishedName = EFalse;

    }

    else

        status = KErrArgument;

    return (status);

}

//////////////////////////////////////////////////////////////////////////////

// SetDistinguishedNameExtended

//////////////////////////////////////////////////////////////////////////////

// Set distinguished name parameter. Complete distinguished name in format

// CN=xxx,O=abc,OU=def or CN=xxx/O=abc/OU=def

// OIds and corresponding texts (case insensitive):

// KX520CountryName             "2.5.4.6"       "c"                     {0x55, 0x04, 0x06}

// KX520OrganizationName        "2.5.4.10"      "o"                     {0x55, 0x04, 0x0a}

// KX520OrganizationalUnitName  "2.5.4.11"      "ou"                    {0x55, 0x04, 0x0b}

// KX520LocalityName            "2.5.4.7"       "l"                     {0x55, 0x04, 0x07}

// KX520StateOrProvinceName     "2.5.4.8"       "st"                    {0x55, 0x04, 0x08}

// KX520Title                   "2.5.4.12"      "title"                 {0x55, 0x04, 0x0c}

// KX520CommonName              "2.5.4.3"       "cn"                    {0x55, 0x04, 0x03}

// KX520GivenName               "2.5.4.42"      "GivenName"             {0x55, 0x04, 0x2a}

// KX520Surname                 "2.5.4.4"       "sn"                    {0x55, 0x04, 0x04}

// KX520Initials                "2.5.4.43"      "initials"              {0x55, 0x04, 0x2b}

// KX520GenerationQualifier     "2.5.4.44"      "generationQualifier"   {0x55, 0x04, 0x2c}

// KX520DNQualifier             "2.5.4.46"      "dnQualifier"           {0x55, 0x04, 0x2e}

// KX520SerialNumber            "2.5.4.5"       "serialNumber"          {0x55, 0x04, 0x05}

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TInt CPkcs10Req::SetDistinguishedNameExtendedL(const TDesC8 &aDistinguishedName)

{

    TInt status = KErrNone;

    // Set distiguished name

    if(aDistinguishedName.Length() > 0)

    {

        delete iDNDerBuf;       // delete possible old buffer

        iDNDerBuf = NULL;

        TRAPD(status, BuildDistinguishedNameDerFromTextL(iDNDerBuf, aDistinguishedName, EFalse, KCountryName()));

        if(status == KErrNone)

        {

            iUseExtendedDistinguishedName = ETrue;

        }

    }

    else

        status = KErrArgument;

    return (status);

}

//////////////////////////////////////////////////////////////////////////////

// BuildDistinguishedNameDerFromText

//////////////////////////////////////////////////////////////////////////////

EXPORT_C void CPkcs10Req::BuildDistinguishedNameDerFromTextL(

    HBufC8        *&derBuffer,

    const TDesC8   &aDistinguishedName,

    TBool           aByPass,

    const TDesC8   &aByPassType

)

{    

    HBufC8 *shrinkedBuffer;

    CArrayFixFlat<TIndexPair> *valueIndexArray  =

      new (ELeave) CArrayFixFlat<TIndexPair>(1);

    CleanupStack::PushL(valueIndexArray);

    CArrayFixFlat<TIndexPair> *typeIndexArray  =

      new (ELeave) CArrayFixFlat<TIndexPair>(1);

    CleanupStack::PushL(typeIndexArray);

    CArrayFixFlat<TPtr8> *valuePtrArray  =

      new (ELeave) CArrayFixFlat<TPtr8>(1);

    CleanupStack::PushL(valuePtrArray);

    CArrayFixFlat<TPtr8> *typePtrArray  =

      new (ELeave) CArrayFixFlat<TPtr8>(1);

    CleanupStack::PushL(typePtrArray);

    // Scan input and build index arrays for types and values

    CPkcs10Req::BuildIndexPairsLC(

        shrinkedBuffer,

        aDistinguishedName,

        typeIndexArray,

        valueIndexArray

    );

    CPkcs10Req::BuildDerL(

        shrinkedBuffer,

        derBuffer,

        typeIndexArray,

        valueIndexArray,

        typePtrArray,

        valuePtrArray,

        aByPass,

        aByPassType

    );

    CleanupStack::PopAndDestroy(5);    

}

//////////////////////////////////////////////////////////////////////////////

// AttributeTypeOidToText

//////////////////////////////////////////////////////////////////////////////

EXPORT_C TPtrC8 CPkcs10Req::AttributeTypeOidToText(const TDesC &aType)

{

    TPtrC8 temp;

    if(aType.Compare(KX520CountryName) == 0)

        temp.Set(KCountryName);

    else if(aType.Compare(KX520OrganizationName) == 0)

        temp.Set(KOrganizationName);

    else if(aType.Compare(KX520OrganizationalUnitName) == 0)

        temp.Set(KOrganizationalUnitName);

    else if(aType.Compare(KX520LocalityName) == 0)

        temp.Set(KLocalityName);

    else if(aType.Compare(KX520StateOrProvinceName) == 0)

        temp.Set(KStateOrProvinceName);

    else if(aType.Compare(KX520Title) == 0)

        temp.Set(KTitle);

    else if(aType.Compare(KX520CommonName) == 0)

        temp.Set(KCommonName);

    else if(aType.Compare(KX520GivenName) == 0)

        temp.Set(KGivenName);

    else if(aType.Compare(KX520Surname) == 0)

        temp.Set(KSurname);

    else if(aType.Compare(KX520Initials) == 0)

        temp.Set(KInitials);

    else if(aType.Compare(KX520GenerationQualifier) == 0)

        temp.Set(KGenerationQualifier);

    else if(aType.Compare(KX520DNQualifier) == 0)

        temp.Set(KDNQualifier);

    else if(aType.Compare(KX520SerialNumber) == 0)

        temp.Set(KSerialNumber);

    else if(aType.Compare(KRFC2247DomainComponent) == 0)

        temp.Set(KDomainComponent);

    else

        {

        // Return dotted oid, length = 0

        }

    return temp;

}

//////////////////////////////////////////////////////////////////////////////

// BuildIndexPairsLC

//////////////////////////////////////////////////////////////////////////////

void CPkcs10Req::BuildIndexPairsLC(

    HBufC8                     *&buffer,

    const TDesC8                &aDistinguishedName,

    CArrayFixFlat<TIndexPair>   *aTypePairArray,

    CArrayFixFlat<TIndexPair>   *aValuePairArray

)

{

    // Some rules:

    // 1) Separator: ','

    // 2) Escape character '\'

    // 3) Value may be quoted. Then separator in value is allowed

    //    (without preceding escape char)

    HBufC8 *sourceBuffer;

    HBufC8 *targetBuffer;

    TUint i, j;

    targetBuffer = HBufC8::NewLC(aDistinguishedName.Length());

    targetBuffer->Des().SetLength(aDistinguishedName.Length());

    sourceBuffer = HBufC8::NewLC(aDistinguishedName.Length());

    sourceBuffer->Des().Copy(aDistinguishedName);

    TPtr8 sourcePointer = sourceBuffer->Des();

    TPtr8 targetPointer = targetBuffer->Des();

    TBool insideQuotes = EFalse;

    TIndexPair pair;

    TUint elementStartPosition = 0;

    TUint elementEndPosition = 0;

    // Delete leading and trailing spaces

    sourcePointer.Trim();

    // Scan text in order to collect name value pairs

    for(i = 0, j = 0; (TInt)i < sourcePointer.Length(); i++)

    {

        if(sourcePointer[i] == '"')

        {

            // Toggle quote state

            // Don't ignore quotes in order to ease trimming.

            // (Spaces inside quotes are meaningful)

            insideQuotes = !insideQuotes;

            targetPointer[j] = sourcePointer[i];

            j++;

            continue;

        }       

        if(insideQuotes)

        {

            // Allow any character

            // Check for escape

            if(sourcePointer[i] == '\\')

            {

                if((TInt)i < sourcePointer.Length() - 1)

                {

                    targetPointer[j] = sourcePointer[i + 1];

                    j++;

                    i++;    // skip char

                }

                else

                    User::Leave(KErrArgument);

            }

            else

            {

                targetPointer[j] = sourcePointer[i];

                j++;

            }

            continue;

        }

        // Check for escape

        if(sourcePointer[i] == '\\')

        {

            if((TInt)i < sourcePointer.Length() - 1)

            {

                targetPointer[j] = sourcePointer[i + 1];

                j++;

                i++;    // skip char

            }

            else

                User::Leave(KErrArgument);

            continue;

        }

        // Check for pair separator

        if(sourcePointer[i] == ',')

        {

            // End of type/value pair

            elementEndPosition = j;

            pair.startIndex = elementStartPosition;

            pair.endIndex = elementEndPosition;

            aValuePairArray->AppendL(pair);

            elementStartPosition = j;

        }

        // Check for type/value separator

        else if(sourcePointer[i] == '=')

        {

            elementEndPosition = j;

            pair.startIndex = elementStartPosition;

            pair.endIndex = elementEndPosition;

            aTypePairArray->AppendL(pair);

            elementStartPosition = j;

        }

        else

        {

            // Plain copy

            targetPointer[j] = sourcePointer[i];

            j++;

        }

    }

    // Append final value

    elementEndPosition = j;

    pair.startIndex = elementStartPosition;

    pair.endIndex = elementEndPosition;

    aValuePairArray->AppendL(pair);

    // Ensure we have consistent type/value pairs

    if(aTypePairArray->Count() != aValuePairArray->Count())

    {

        User::Leave(KErrArgument);

    }

    CleanupStack::PopAndDestroy(1);         // source

    // Return allocated shrinked buffer and OK status

    targetBuffer->Des().SetLength(j);

    buffer = targetBuffer;    

}

//////////////////////////////////////////////////////////////////////////////

// BuildDerLC

//////////////////////////////////////////////////////////////////////////////

void CPkcs10Req::BuildDerL(

    HBufC8                      *aSource,

    HBufC8                     *&derBuffer,

    CArrayFixFlat<TIndexPair>   *aTypeIndexArray,

    CArrayFixFlat<TIndexPair>   *aValueIndexArray,

    CArrayFixFlat<TPtr8>        *aTypePtrArray,

    CArrayFixFlat<TPtr8>        *aValuePtrArray,

    TBool                        aByPass,

    const TDesC8                &aByPassType

)

{

    TUint i;

    // trim types and values and count required der length

    TUint elementLength = 0;

    TUint totalLength = 0;

    TUint wholeLength = 0;

    TUint setLength = 0;

    TUint seqLength = 0;

    TUint oidLength = COMMON_NAME_OID_LTH;

    TUint stringLength = 0;

    TUint contentLength = 0;

    TUint oidIndex = 0;

    TBuf8<32> dottedOidDer;

    CArrayFixFlat<HBufC8 *> *elementArray =

      new (ELeave) CArrayFixFlat<HBufC8 *>(1);

    CleanupStack::PushL(elementArray);

    for(i = 0; (TInt)i < aTypeIndexArray->Count(); i++)  // counts are equal

    {

        TPtr8 tempPtr(

            CONST_CAST(TUint8*, aSource->Des().Ptr()) + aTypeIndexArray->At(i).startIndex,

            aTypeIndexArray->At(i).endIndex - aTypeIndexArray->At(i).startIndex

        );

        tempPtr.SetLength(

            aTypeIndexArray->At(i).endIndex - aTypeIndexArray->At(i).startIndex

        );

        aTypePtrArray->AppendL(tempPtr);

        tempPtr.Set(

            CONST_CAST(TUint8*, aSource->Des().Ptr()) + aValueIndexArray->At(i).startIndex,

            aValueIndexArray->At(i).endIndex - aValueIndexArray->At(i).startIndex,

            aValueIndexArray->At(i).endIndex - aValueIndexArray->At(i).startIndex

        );

        tempPtr.SetLength(aValueIndexArray->At(i).endIndex - aValueIndexArray->At(i).startIndex);

        tempPtr.Trim();

        if(0 == tempPtr.Length())

        {

            User::Leave(KErrArgument);

        }

        // Remove quotes. Spaces inside quotes are meaningful,

        // so Trim must be called before this operation

        if(tempPtr[0] == '"')

        {

            if(tempPtr[tempPtr.Length() -1 ] != '"')

            {                

                User::Leave(KErrArgument);

            }

            else

            {

                TInt tempLength = tempPtr.Length() - 2; 

                tempPtr.Set(CONST_CAST(TUint8*, tempPtr.Ptr() + 1), tempLength, tempLength);

                tempPtr.SetLength(tempLength);

            }

        }

        if(0 == tempPtr.Length())

        {

            User::Leave(KErrArgument);

        }

        aValuePtrArray->AppendL(tempPtr);

        aTypePtrArray->At(i).Trim();

        aTypePtrArray->At(i).UpperCase();

        // Check if type is supported, it is ignored if not

        if(CPkcs10Req::OidExistsL(aTypePtrArray->At(i), oidIndex, dottedOidDer))

        {

            if(KNullAttributeIndex == oidIndex)

            {

                oidLength = dottedOidDer.Length() - ASN1_SHORT_TAG_HDR_LTH;

            }

            else if(KDomainComponentIndex == oidIndex)

            {

                oidLength = DC_OID_LTH;

            }

            else

            {

                oidLength = COMMON_NAME_OID_LTH;

            }

            if(!(aByPass && aTypePtrArray->At(i).Compare(aByPassType) == 0))

            {

                // Printable string

                elementLength = aValuePtrArray->At(i).Length();

                stringLength = elementLength;

                if(elementLength > 127)

                    elementLength++;

                if(elementLength > 255)

                    elementLength++;

                elementLength += ASN1_SHORT_TAG_HDR_LTH;

                elementLength += oidLength;               // Oid 

                elementLength += ASN1_SHORT_TAG_HDR_LTH;        

                seqLength = elementLength;

                if(elementLength > 127)

                    elementLength++;

                if(elementLength > 255)

                    elementLength++;

                elementLength += ASN1_SHORT_TAG_HDR_LTH;  // Sequence

                setLength = elementLength;

                if(elementLength > 127)

                    elementLength++;

                if(elementLength > 255)

                    elementLength++;

                elementLength += ASN1_SHORT_TAG_HDR_LTH;  // Set

                wholeLength = elementLength;

                // Build one element

                CPkcs10Req::BuildElementDerLC(

                    elementArray,

                    wholeLength, 

                    setLength,

                    seqLength, 

                    oidLength,

                    stringLength, 

                    oidIndex,

                    dottedOidDer, 

                    aValuePtrArray->At(i)

                );            

                totalLength += elementLength;

            }

        }

    }

    if( 0 == totalLength )

    {

        User::Leave(KErrArgument);

    }

    contentLength = totalLength;

    if(totalLength > 127)                                   // Sequence

        totalLength++;

    if(totalLength > 255)

        totalLength++;

    totalLength += ASN1_SHORT_TAG_HDR_LTH;

    // Allocate buffer

    derBuffer = HBufC8::NewL(totalLength);

    derBuffer->Des().SetLength(totalLength);

    TUint8 *derBufferPtr = (TUint8 *)derBuffer->Ptr();

    derBufferPtr+= CPkcs10Req::DERSetTag(derBufferPtr, (EASN1Sequence | ASN1_CONSTRUCTED));

    derBufferPtr+= CPkcs10Req::DERSetLength(derBufferPtr, contentLength);

    for(i = 0; (TInt)i < elementArray->Count(); i++)

    {

        derBufferPtr+= CPkcs10Req::ASNCopy(

            derBufferPtr,

            CONST_CAST(unsigned char *, elementArray->At(i)->Des().Ptr()),

            elementArray->At(i)->Length()

        );

    }

    CleanupStack::PopAndDestroy(elementArray->Count());

    CleanupStack::PopAndDestroy(elementArray);

}

//////////////////////////////////////////////////////////////////////////////

// OidExistsLC

///////////////////////////////////////////////////////////////////////////////

TBool CPkcs10Req::OidExistsL(

    TPtr8 &aTypePtrArray,

    TUint &aIndex,

    TBuf8<32> &aDottedOidDer

)

{

TBool validOId = EFalse;

    aIndex = KNullAttributeIndex;

    if(aTypePtrArray.Compare(KCountryName) == 0)

        aIndex = KCountryNameIndex;

    else if(aTypePtrArray.Compare(KOrganizationName) == 0)

        aIndex = KOrganizationNameIndex;

    else if(aTypePtrArray.Compare(KOrganizationalUnitName) == 0)

        aIndex = KOrganizationalUnitNameIndex;