/*

* Copyright (c) 2008-2009 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:   static method for certficate handling

*

*/

#include <x509cert.h>

#include <asn1dec.h>

#include <x500dn.h>

#include "ikepkiutils.h"

#include "ikev1pkiservice.h"

#include "ikepublickey.h"

#include "utlcrypto.h"

#include "ikecert.h"

#include "ikecalist.h"

#include "ikecaelem.h"

#include "ikev2const.h"

#include "ikev2payloads.h"

#include "ikecertconst.h"

EXPORT_C TBool IkePkiUtils::CertifyIdentityL(const CX509Certificate* aCert, 

                                             TDesC8& aId, TInt aIdType)

    {

	TBool status = EFalse;

	if ( aCert )

	    {	

	   //

	   // Check that specified identity exist in current certificate

	   // data. If aIdType type is ID_DER_ASN1_DN, identity must match

	   // with Certificate Subject name. 

	   // All other aIdTypes ara checked against SubjectAltNames data,

	   // if present 

	   //

		if ( aIdType == ID_DER_ASN1_DN )

		    {

	        //

	        // Binary DER encoding of an ASN.1 X.500 Distinguished Name identity

	        // is certified by comparing it to peer certificate subject name

	        //

			CX500DistinguishedName* asn1DnName = CX500DistinguishedName::NewLC(aId);

		    status = asn1DnName->ExactMatchL(aCert->SubjectName());			   			   

		    CleanupStack::PopAndDestroy(asn1DnName);

		    }

		else

		    {

            //

            // Other identity types are certified by comparing it to the SubjectAltName field        

            //

			HBufC8* idBuf = HBufC8::NewLC(aId.Length() + 2);

			TUint8* idHdr = (TUint8*)idBuf->Des().Ptr();

			idHdr[1]      = (TUint8)aId.Length();

			switch ( aIdType ) 

			    {

				case ID_IPV4_ADDR:

					idHdr[0] = 0x87;

					break;

				case ID_FQDN:

					idHdr[0] = 0x82;                       

					break;

				case ID_RFC822_ADDR:

					idHdr[0] = 0x81;                                   

					break;

				case ID_IPV6_ADDR:

					idHdr[0] = 0x87;           

					break;

				default:

					idHdr = NULL;

                    break;

		    	}

			if ( idHdr )

			    {	

			   Mem::Copy(&idHdr[2], aId.Ptr(), aId.Length());

			   TPtrC8 ptrId(idHdr, (aId.Length() + 2));

			   status = IkeCert::AltNameExistsL(aCert, ptrId);

		    	}

			CleanupStack::PopAndDestroy();  //IdBuf			

		    }

    	}	

	return status;

    }

EXPORT_C TBool IkePkiUtils::VerifyIkev2SignatureL(const TDesC8& aSignature, 

                                                  const TDesC8& aAuthData, 

                                                  const CX509Certificate& aCert)

    {

	//

	// Calculate SHA1 hash over aAuthdata to build reference hash and

	// verify IKEv2 signature with it

	//

	CUtlMessageDigest* Digest = TUtlCrypto::MakeMessageDigesterL(TUtlCrypto::EUtlMessageDigestSha1);

	CleanupStack::PushL(Digest);			

	TPtrC8 RefHash = Digest->Final(aAuthData);

	TBool Status   = VerifySignatureL(MAJORV2, aSignature, RefHash, aCert);

	CleanupStack::PopAndDestroy(Digest);

	return Status; 

    }	 

EXPORT_C TBool IkePkiUtils::VerifyIkev1SignatureL(const TDesC8& aSignature, 

                                                  const TDesC8& aRefHash, 

                                                  const CX509Certificate& aCert)

    {

	//

	// Verify IKEv1 signature. 

	//

	return VerifySignatureL(MAJORV1, aSignature, aRefHash, aCert);

    }	 

EXPORT_C HBufC8* IkePkiUtils::GetIdentityFromCertL(TUint8 aIdType, const TDesC8& aCertData)

    {

	//

	// Get IKE Identity data from specified Certificate data. The Id

	// type parameter specifies the field of Certificate from where the

	// Identity data is taken

	//

	HBufC8* identity;

	CX509Certificate* cert = CX509Certificate::NewL(aCertData);

	CleanupStack::PushL(cert);			

	if ( (aIdType == ID_DER_ASN1_DN) || (aIdType == ID_NOT_DEFINED) || (aIdType > ID_IPV6_ADDR) )

	    {       

	    // 

	    // DER encoded ASN.1 X.500 Distinguished Name as IKE identity

		// Get Id data from certificate subject name

	    //

		identity = IkeCert::GetCertificateFieldDERL(cert, KSubjectName);

	    }

	else

	    {

	     //

	     // Get IKE Identity from own certifate subject alt name extension (according to IdType value)

	     //

		identity = IkeCert::GetSubjectAltNameDataL(cert, aIdType); 

	    }

	CleanupStack::PopAndDestroy(cert); 

	return identity;

    }	 

EXPORT_C TBool IkePkiUtils::GetCertSubjectNameDERL(const CX509Certificate* aCert, 

                                                   TDes8& aSubjectName)

    {

	TBool status = ETrue;

	HBufC8* nameBfr = IkeCert::GetCertificateFieldDERL(aCert, KSubjectName);

    if ( nameBfr && ( nameBfr->Des().Length() <= aSubjectName.MaxLength() ) )

	    {

		aSubjectName.Copy(nameBfr->Des());

		delete nameBfr;

	    }

	else 

	    {

		aSubjectName.SetLength(0);

		status = EFalse;

	    }

	return status;

    }	        

EXPORT_C CX509Certificate* IkePkiUtils::VerifyCertificateL(const CArrayFixFlat<const TCertificateISAKMP*>& aCerts,

                                                           const CIkeCaList& aTrustedCAList)

    {

    const CArrayFixFlat<TCertPayloadIkev2*>* certificateArray = IkePkiUtils::CastCertArray(&aCerts);    

    return VerifyCertificateL(*certificateArray, aTrustedCAList);

    }

EXPORT_C CX509Certificate* IkePkiUtils::VerifyCertificateL(const CArrayFixFlat<TCertPayloadIkev2*>& aCerts,

                                                           const CIkeCaList& aTrustedCAList)

   {

	//

	// Find a requested certificate or chain of certificates from IKE certificate payload array

	// using trusted CA list (iTrustedCAList).

	// When requested certificate found verify this certificate. 

	//

	CX509Certificate* certOk = NULL;	

	CX509Certificate* caCert = NULL;

	CX509Certificate* currCert=NULL;

	const TCertPayloadIkev2* firstCertPayload=NULL;

	const TCertPayloadIkev2* certPayload = aCerts.At(0);

    __ASSERT_DEBUG(certPayload != NULL, User::Invariant());

    CArrayFixFlat<CX509Certificate*>* caArray=new (ELeave) CArrayFixFlat<CX509Certificate*> (aCerts.Count());

    CleanupStack::PushL(caArray);

    for ( TInt i = 0; i < aCerts.Count(); i++  ) 

        {

         const TCertPayloadIkev2* currCertPayload=aCerts.At(i);

         __ASSERT_DEBUG(currCertPayload != NULL, User::Invariant());

         if ( currCertPayload->GetEncoding() == X509_CERTIFICATE_SIGN )

        {          

             firstCertPayload=currCertPayload;

             const TPtrC8 CertStream(currCertPayload->Certificate(),

                                    (TPayloadIkev2::Cast(currCertPayload)->GetLength() - 

                                     TCertPayloadIkev2::Size()));

             currCert = CX509Certificate::NewLC(CertStream);

             caArray->AppendL(currCert);

            }

        }

    if ( caArray->Count() == 1)

           {

         const TPtrC8 userCertStream(firstCertPayload->Certificate(),

                                    (TPayloadIkev2::Cast(firstCertPayload)->GetLength() - 

                                     TCertPayloadIkev2::Size()));

         firstCertPayload=NULL;

            CX509Certificate* clientCert = CX509Certificate::NewLC(userCertStream);

            caCert = IkePkiUtils::FindCaCertificateL(*clientCert, aTrustedCAList);

            if ( caCert )

                {

                 certOk = IkePkiUtils::VerifyX509CertificateL(*caCert, *clientCert);

             if ( certOk )  // CertOk = clientCert

                    {

                     CleanupStack::Pop(clientCert);  // CertOk = Cert              

                clientCert=NULL;

                CleanupStack::PopAndDestroy(currCert);

                currCert=NULL;

                CleanupStack::PopAndDestroy(caArray);

                caArray=NULL;

                return certOk; 

                }

            }   

         CleanupStack::PopAndDestroy(clientCert);  // Cert

         clientCert=NULL;

         CleanupStack::PopAndDestroy(currCert);

         currCert=NULL;

         CleanupStack::PopAndDestroy(caArray);

         caArray=NULL;

         return NULL;

         }

    if ( caArray->Count()>1 ) //if certificate chain is received

       {    

           CX509Certificate* userCert=NULL;

           CX509Certificate* certChainRoot = IkePkiUtils::VerifyCertChainL(*caArray, userCert, aTrustedCAList);

           CX509Certificate* realUserCert=userCert; //Real user certificate found from chain as a parameter by reference 

           //cleaning

           TInt certCount=caArray->Count();

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

               CleanupStack::Pop();

           CleanupStack::Pop(caArray);

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

               {

                CX509Certificate* itemPtr=caArray->At(i);

                if ( realUserCert != itemPtr && certChainRoot != itemPtr )

                    delete itemPtr;

               }

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

                 caArray->Delete(0);

           delete caArray;

           if ( certChainRoot )

               caCert = IkePkiUtils::FindCaCertificateL(*certChainRoot, aTrustedCAList);

           else

               caCert=NULL;

           if ( caCert )

               certOk = IkePkiUtils::VerifyX509CertificateL(*caCert, *certChainRoot);

           if ( certChainRoot != userCert )

           			delete certChainRoot;

           if ( certOk )

              return realUserCert;

           else

              return NULL;

           }

    return NULL;

    }

EXPORT_C const CArrayFixFlat<TCertPayloadIkev2*>* IkePkiUtils::CastCertArray(const CArrayFixFlat<const TCertificateISAKMP*>* aCerts) 

    { 

    return reinterpret_cast<const CArrayFixFlat<TCertPayloadIkev2*>*>(aCerts); 

    }

CX509Certificate* IkePkiUtils::VerifyX509CertificateL(const CX509Certificate& aCaCert, 

                                                      CX509Certificate& aCert)

    {

	TPKIKeyAlgorithm reqKeyType = EPKIInvalidAlgorithm;

	switch (aCert.SigningAlgorithm().AsymmetricAlgorithm().Algorithm())

    	{

		case ERSA:

			reqKeyType = EPKIRSA;

			break;

		case EDSA:

			reqKeyType = EPKIDSA;

			break;

		default:

			break;

	    }

	if ( reqKeyType == EPKIInvalidAlgorithm )

		return NULL;

	CIkePublicKey* pubKey = CIkePublicKey::NewL(aCaCert);

	if ( !pubKey )

		return NULL;	

	if ( reqKeyType != pubKey->Algorithm() )

	    {

		delete pubKey;

		return NULL;

	    }	

	CleanupStack::PushL(pubKey);

	TInt  ret   = KErrNotSupported;

	TBool valid = EFalse;

	switch (pubKey->Algorithm())

    	{

		case EPKIRSA:

			TRAP(ret, valid = aCert.VerifySignatureL(pubKey->KeyData()));

			break;

		case EPKIDSA:

		    {

			TX509KeyFactory keyFactory;

			CDSAParameters* params = keyFactory.DSAParametersL(pubKey->KeyParams());

			CleanupStack::PushL(params);

			CSigningKeyParameters*sgkp = CSigningKeyParameters::NewLC();

			sgkp->SetDSAParamsL(*params);

			aCert.SetParametersL(*sgkp);

			TRAP(ret, valid = aCert.VerifySignatureL(pubKey->KeyData()));

			CleanupStack::PopAndDestroy(sgkp); 

			CleanupStack::PopAndDestroy(params); 

			break;

		    }

		case EPKIInvalidAlgorithm:

			break;

	    }

	CX509Certificate* ValidCert = NULL;	

	if ( valid && (ret == KErrNone) )

	    {

		//

		// One hour error margin, no warning margin

		//

		ret = IkeCert::CheckValidityPeriod(aCert, 0, KDefaultErrorMargin);

		if ( ret == KErrNone )

	    	{	

			//

			// Verify certificate extensions

			//

			ret = IkeCert::VerifyCertExtensionsL(aCert);

			if ( ret == KErrNone || ret == KCertVerifyCACertificate )

				ValidCert = &aCert;			

	    	}		

    	}	

	CleanupStack::PopAndDestroy(pubKey);

	return ValidCert;  

}

CX509Certificate* IkePkiUtils::FindCaCertificateL(const CX509Certificate& aUserCert,

                                                  const CIkeCaList& aTrustedCAList)

    {

	//

	// Find a CA certificate from Trusted CA list (iTrustedCAList) for

	// specified user certificate

	//	

	const CX500DistinguishedName& issuerName = aUserCert.IssuerName();	

	CX509Certificate* caCert = NULL;

    for (TInt i = 0; i < aTrustedCAList.Count(); i++)

	    {

    	//

	    // Find CA certificate for current user certificate by

	    // comparing certificate issuer name to the subject name of a

	    // CA certificate

	    //		

		caCert = aTrustedCAList.At(i)->Certificate();

		if ( issuerName.ExactMatchL(caCert->SubjectName()) )

		    {

		    break;	

		    }

		caCert = NULL;

	    }	

	return caCert;

    }

TBool IkePkiUtils::VerifySignatureL(TInt aIkeVersion, 

                                    const TDesC8& aSignature, 

                                    const TDesC8& aRefHash, 

                                    const CX509Certificate& aCert)

    {

	//

	// Verify IKE signature. 

	//

	TBool status = EFalse;

	if ( aSignature.Length() > 0 )	

	    {	    	

    	CIkePublicKey* publicKey = CIkePublicKey::NewL(aCert);

    	if ( !publicKey )

    	    {	    

    		return EFalse;			

    	    }

    	CleanupStack::PushL(publicKey);			

    	switch (publicKey->Algorithm())

    	    {

    		case EPKIRSA:

    			{

                HBufC8 *resBuf;

                TUtlCrypto::RsaPublicKeyDecryptL(publicKey->KeyData(), aSignature, resBuf);

                CleanupStack::PushL(resBuf);							

                if ( aIkeVersion == MAJORV1 ) 

                    {

                    //

                    // Because IKEv1 signature is not a "real" PKCS1

                    // encoded signature but pure private encrypted has

                    // signature is verified by using RSA public key

                    // decrypt and result comparison to reference hash

                    //

                    status = (aRefHash.Compare(*resBuf) == 0); //Compare the result with the hash to see if they match

                    }

                else

    				{

                    //

                    // IKEv2(n) signature is encoded as PKCS1v1_5

                    // signature (EMSA-PKCS1-v1_5)

                    // ASN1 encoding of signature is the following:

                    //	DigestInfo::=SEQUENCE{

                    //	  digestAlgorithm  AlgorithmIdentifier,

                    //	  digest OCTET STRING }

                    //

                    CArrayPtrFlat<TASN1DecGeneric>* seq = NULL;

                    TInt position = 0;

                    TRAPD(err, seq = DecodeDERL(*resBuf, position));

                    if ( err == KErrNone )

                        {

                        TCleanupItem CleanupSeq(IkeCert::CleanupSequence, seq);						

                        CleanupStack::PushL(CleanupSeq);

                        if (seq->Count() == 2)

                            {

                            //

                            // Currently the digestAlgorithm is not

                            // verified, but only digest value itself is

                            // compared with reference hash.

                            // ( see CPKCS1SignatureResult::DoVerifyL() in

                            //   x509cert.cpp)

                            // 

                            const TASN1DecGeneric* gen2 = seq->At(1);                            

                            TPtrC8 digest(gen2->GetContentDER());

                            status = (aRefHash.Compare(digest) == 0);

                            }

                        CleanupStack::PopAndDestroy(); //CleanupSeq

                        }

                    else

                        {

                        //

                        // Verify signature as pure encrypted (SHA1)

                        // hash as old IKEv1 style "signature" 

                        //

                        //DEB(iService.PrintText(_L("Old IKEv1 style signature used by IKEv2 peer !\n"));)					   

                        status = (aRefHash.Compare(*resBuf) == 0); //Compare the result with the hash to see if they match					   

                        }	

    				}

                CleanupStack::PopAndDestroy(resBuf);

    			break;

    			}

            case EPKIDSA:

                {

                const TPtrC8 sigR = aSignature.Left(aSignature.Length() / 2);

                const TPtrC8 sigS = aSignature.Right(aSignature.Length() / 2);

                status = TUtlCrypto::DsaVerifySignatureL(publicKey->KeyData(), 

                                                         publicKey->KeyParams(), 

                                                         sigR, sigS, aRefHash);

                break;

                }

            default:        //Only RSA and DSA are valid

                User::Invariant();

            	break;

    		}

    	CleanupStack::PopAndDestroy(publicKey);

	    }

	return status;

    }	

CArrayPtrFlat<TASN1DecGeneric>* IkePkiUtils::DecodeDERL(const TDesC8& aPtr, TInt& aPosition)

    {

	TASN1DecSequence decSeq;

	CArrayPtrFlat<TASN1DecGeneric>* seq =	decSeq.DecodeDERLC(aPtr, aPosition);

	CleanupStack::Pop(seq);

	return seq;

    }

EXPORT_C CX509Certificate* IkePkiUtils::VerifyCertChainL(const CArrayFixFlat<CX509Certificate*>& aCerts, CX509Certificate*& realUserCert, const CIkeCaList& aTrustedCAList)

    {

    CX509Certificate* currCaCert=NULL;

    CX509Certificate* certOk=NULL;

    CArrayFixFlat<const CX500DistinguishedName*>* issuerArray=new (ELeave) CArrayFixFlat<const CX500DistinguishedName*> (aCerts.Count());