/*

* Copyright (c) 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: Class with methods used in sign and verification process.       

*

*/

// XML Engine

#include <libxml2_tree.h>

#include <libxml2_xmlmemory.h>

#include <libxml2_parser.h>

#include <libxml2_globals.h>

#include <xmlengmem.h>

#include <xmlengxestd.h>

#include <xmlengutils.h>

#include <xmlengxestrings.h>

#include <xmlengdom.h>

// XML Sec

#include "xmlsec_crypto.h"

#include "xmlsec_xmlsec.h"

#include "xmlsec_xmltree.h"

#include "xmlsec_xmldsig.h"

#include "xmlsec_templates.h"

#include "xmlsecc_x509.h"

#include "xmlsecwsign.h"

#include "xmlsecwkeymanager.h"

#include "xmlsecwerrors.h"

#include "xmlsecwdefs.h"

#include "xmlsecwtemplate.h"

#include "xmlsecwinternalutils.h"

#include "xmlsecwglobalstate.h"

namespace Sign

    {

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

// Reset sign ctx

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

// 

xmlSecDSigCtxPtr ResetCtxL(xmlSecDSigCtxPtr aCtx, CXmlSecKeyManager* aMngr)

    {

    xmlSecKeyPtr tmpKey = NULL;

    if(!aMngr)

        {

        tmpKey = aCtx->signKey;

        aCtx->signKey = NULL;

        }

    // destroy old ctx

    xmlSecDSigCtxDestroy(aCtx);

    // create new ctx

    if(aMngr)

        {

        aCtx = xmlSecDSigCtxCreate(aMngr->GetKeyManagerPtr());

        }

    else

        {

        aCtx = xmlSecDSigCtxCreate(NULL);

        }

    // add key if needed

    if ( !aCtx  ) 

        {

        if ( tmpKey ) 

            {

	        xmlSecKeyDestroy( tmpKey );

            }

        User::Leave( KErrNoMemory );

        }

    aCtx->signKey = tmpKey;

    tmpKey = NULL;

    return aCtx;

    }

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

// Read key from file

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

//  

xmlSecKeyPtr ReadKeyFromFileL(const TDesC8& aKeyFile,

                              const TDesC8& aKeyName,

                              CXmlSecSign::TXmlSecKeyType aKeyFormat)

    {

    if(aKeyFile.Length() == 0)

        {

        User::Leave(KErrWrongParameter);

        }

    xmlSecKeyPtr keyPtr = NULL;

    char* file = XmlEngXmlCharFromDes8L(aKeyFile);

    CleanupStack::PushL(file);

    char* name = XmlEngXmlCharFromDes8L(aKeyName); 

    CleanupStack::PushL(name);

    // load key - used method depend key type

    if (aKeyFormat == CXmlSecSign::ERSAPrivate)

        {

        if(aKeyName.Length() == 0)

            {

            User::Leave(KErrWrongParameter);

            }

        keyPtr = xmlSecCryptoAppKeyLoadWithName(file, xmlSecKeyDataFormatPkcs8Der,

                                    name, NULL, NULL, NULL);

        }

    else if (aKeyFormat == CXmlSecSign::ERSAPublic)

        {

        if(aKeyName.Length() == 0)

            {

            User::Leave(KErrWrongParameter);

            }

        keyPtr = xmlSecCryptoAppKeyLoadWithName(file, xmlSecKeyDataFormatDer,

                                    name, NULL, NULL, NULL);

        }

    else if (aKeyFormat == CXmlSecSign::EHMAC)

        keyPtr = xmlSecKeyReadBinaryFile(xmlSecKeyDataHmacId,file);

	if(!keyPtr) 

        {

        XmlEngOOMTestL();

        XmlSecErrorFlagTestL();

        User::Leave(KErrKey);

        }

    const xmlChar* KTmpName = NULL;

    if(aKeyName.Length())

        {

        KTmpName = (xmlChar*) name;

        }

    // add key name to key

    if((aKeyFormat == CXmlSecSign::EHMAC) && (xmlSecKeySetName(keyPtr,KTmpName) < 0))

        {

        xmlSecKeyDestroy(keyPtr);

        XmlEngOOMTestL();

        XmlSecErrorFlagTestL();

        User::Leave(KErrKey);

        }

    CleanupStack::PopAndDestroy(name);

    CleanupStack::PopAndDestroy(file);    

    return keyPtr;

    }

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

// Read key from buffer

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

// 

xmlSecKeyPtr ReadKeyFromBufferL(const TDesC8& aBuffer,

                                const TDesC8& aKeyName,

                                CXmlSecSign::TXmlSecKeyType aKeyFormat)

    {

    if(aBuffer.Length() == 0)

        {

        User::Leave(KErrWrongParameter);

        }

    char* name = XmlEngXmlCharFromDes8L(aKeyName); 

    CleanupStack::PushL(name);

    xmlSecKeyPtr keyPtr = NULL;

    // load key - used method depend key type

    if (aKeyFormat == CXmlSecSign::ERSAPrivate)

        {

        if(aKeyName.Length() == 0)

            {

            User::Leave(KErrWrongParameter);

            }

        keyPtr = xmlSecCryptoAppKeyLoadMemoryWithName(aBuffer.Ptr(), aBuffer.Size(),

                                    xmlSecKeyDataFormatPkcs8Der, name, NULL, NULL, NULL);

        }

    else if (aKeyFormat == CXmlSecSign::ERSAPublic)

        {

        if(aKeyName.Length() == 0)

            {

            User::Leave(KErrWrongParameter);

            }

        keyPtr = xmlSecCryptoAppKeyLoadMemoryWithName(aBuffer.Ptr(), aBuffer.Size(),

                                    xmlSecKeyDataFormatDer, name, NULL, NULL, NULL);

        }

    else if (aKeyFormat == CXmlSecSign::EHMAC)

        keyPtr = xmlSecKeyReadMemory(xmlSecKeyDataHmacId,aBuffer.Ptr(), aBuffer.Size());

    XmlEngOOMTestL();

    XmlSecErrorFlagTestL();

    if(!keyPtr) 

        {

        User::Leave(KErrKey);

        }

    const xmlChar* KTmpName = NULL;

    if(aKeyName.Length())

        {

        KTmpName = (xmlChar*) name;

        }

    // add key name to key

    if((aKeyFormat == CXmlSecSign::EHMAC) && (xmlSecKeySetName(keyPtr,KTmpName) < 0))

        {

        xmlSecKeyDestroy(keyPtr);

        XmlEngOOMTestL();

        XmlSecErrorFlagTestL();

        User::Leave(KErrKey);

        }

    CleanupStack::PopAndDestroy(name);

    return keyPtr;

    }

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

// Reset template settings

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

//   

void TemplateCleanup(TAny* aPref)

    {

    if(aPref)

        {

        delete aPref;

        xmlSetPrefix(NULL);

        }

    xmlSetNewLineFlag(1);

    }

    }// namespace Sign

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

// Two phase constructor

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

//   

EXPORT_C CXmlSecSign* CXmlSecSign::NewLC()

    {

    CXmlSecSign* self = new (ELeave) CXmlSecSign;

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// Two phase constructor

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

// 

EXPORT_C CXmlSecSign* CXmlSecSign::NewL()

    {

    CXmlSecSign* self = CXmlSecSign::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

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

// Sign the xml document

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

// 

EXPORT_C TXmlEngElement CXmlSecSign::SignXmlDocumentL(RXmlEngDocument& aDocument, 

                                                      TBool aUseCurrentKey)

    {

    if(aDocument.IsNull())

        {

        User::Leave(KErrWrongParameter);

        }

    return SignXmlNodeL(aDocument.DocumentElement(),aUseCurrentKey);

    }

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

// Sign the xml document

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

// 

EXPORT_C TXmlEngElement CXmlSecSign::SignXmlDocumentKeyFromFileL(RXmlEngDocument& aDocument,

                                                     RXmlEngDocument& aTemplate,

                                                     const TDesC8& aKeyFile,

                                                     const TDesC8& aKeyName,

                                                     TXmlSecKeyType aKeyFormat)

    {

    SetKeyFromFileL(aKeyFile,aKeyName,aKeyFormat);

		if(EFalse == iTemplate.IsSameNode(aTemplate))   

		{

			SetTemplateL(aTemplate);  

		}

		iSkipTmplLookUp = ETrue; //Set to TRUE indicating to skip searching for Template in document

    return SignXmlDocumentL(aDocument);

    }

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

// Sign the xml document

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

// 

EXPORT_C TXmlEngElement CXmlSecSign::SignXmlDocumentKeyFromFileL(RXmlEngDocument& aDocument,

                                                     const TDesC8& aKeyFile,

                                                     const TDesC8& aKeyName,

                                                     TXmlSecKeyType aKeyFormat)

    {

    SetKeyFromFileL(aKeyFile,aKeyName,aKeyFormat);

    return SignXmlDocumentL(aDocument);

    }

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

// Sign the xml document

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

// 

EXPORT_C TXmlEngElement CXmlSecSign::SignXmlDocumentKeyFromBufferL(RXmlEngDocument& aDocument,

                                                       RXmlEngDocument& aTemplate,

                                                       const TDesC8& aKey,

                                                       const TDesC8& aKeyName,

                                                       TXmlSecKeyType aKeyFormat)

    {

    SetKeyFromBufferL(aKey,aKeyName,aKeyFormat);

   	if(EFalse == iTemplate.IsSameNode(aTemplate))   

		{

			SetTemplateL(aTemplate);  

		}  

    iSkipTmplLookUp = ETrue; //Set to TRUE indicating to skip searching for Template in document

    return SignXmlDocumentL(aDocument);

    }

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

// Sign the xml document

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

// 

EXPORT_C TXmlEngElement CXmlSecSign::SignXmlDocumentKeyFromBufferL(RXmlEngDocument& aDocument,

                                                       const TDesC8& aKey,

                                                       const TDesC8& aKeyName,

                                                       TXmlSecKeyType aKeyFormat)

    {

    SetKeyFromBufferL(aKey,aKeyName,aKeyFormat);

    return SignXmlDocumentL(aDocument);

    }

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

// Sign the xml node

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

//     

TXmlEngElement CXmlSecSign::SignXmlNodeL(TXmlEngElement aNode, TBool aUseCurrentKey)

    {

    TXmlEngElement ele;

    TBool add = FALSE;

    xmlSecDSigCtxPtr tmpCtx = SIG_CTX;

    // Reset ctxt

    if(aUseCurrentKey)

        {

        iSigCtx = NULL;

        tmpCtx = Sign::ResetCtxL(tmpCtx,NULL);

        iSigCtx = tmpCtx;

        }

    else

        {

        if(!iMngr)

            {

            iMngr = CXmlSecKeyManager::GetInstanceL();

            }

        iSigCtx = NULL;

        tmpCtx = Sign::ResetCtxL(tmpCtx,iMngr);

        iSigCtx = tmpCtx;

        }        

    xmlNodePtr node = NULL;

    // skip if there is a template already available which may or may not contain Signature(from document)

    if(EFalse == iSkipTmplLookUp)

    {

    // find <Signature> in aNode

    node = xmlSecFindNode(xmlDocGetRootElement(INTERNAL_NODEPTR(aNode)->doc),

                                xmlSecNodeSignature, xmlSecDSigNs);

    }   

 		TXmlEngElement sign(node);

    if(!node)

        {

        if(iTemplate.NotNull())

            {

            // process template

            node = xmlSecFindNode(xmlDocGetRootElement(INTERNAL_DOCPTR(iTemplate)),

                                xmlSecNodeSignature, xmlSecDSigNs);

            if(!node)

                {

                User::Leave(KErrTemplate);

                }

            node = xmlCopyNode(node, 1);

            if(!node)

                {

                User::Leave(KErrNoMemory);

                }

            // add template to document that should be signed

            sign = TXmlEngElement(node);

            aNode.AppendChildL(sign);

            add = TRUE;

            }

        }

    // sign the data

    if(xmlSecDSigCtxSign(tmpCtx, node) < 0) 

        {

        XmlEngOOMTestL();

        XmlSecErrorFlagTestL();

        User::Leave(KErrSign);

        }

    if(add)

        {

        sign.Unlink();    

        }

    iSkipTmplLookUp = EFalse; // Reset the Flag

    return sign;

    }

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

// Sign the xml nodes

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

//     

EXPORT_C TXmlEngElement CXmlSecSign::SignXmlNodesL(RArray<TXmlEngElement>& aNodes,

                                       TBool aUseCurrentKey)

    {

    if(!aNodes.Count())

        {

        User::Leave(KErrWrongParameter);

        }

    return SignXmlNodeL(aNodes[0].OwnerDocument().DocumentElement(),aUseCurrentKey);

    }

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

// Verify xml node

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

//     

EXPORT_C TBool CXmlSecSign::VerifyXmlNodeL(TXmlEngElement aNode, 

                                     TXmlSecVerificationKeyRepository aKeyRepository)

    {

    xmlSecDSigCtxPtr tmpCtx = SIG_CTX;

    // Reset ctxt

    if( aKeyRepository == EThisObject )

        {

        iSigCtx = NULL;

        tmpCtx = Sign::ResetCtxL(tmpCtx,iMngr);

        iSigCtx = tmpCtx;   

        }

    else

        {

        if(!iMngr)

            {

            iMngr = CXmlSecKeyManager::GetInstanceL();

            }

        iSigCtx = NULL;

        tmpCtx = Sign::ResetCtxL(tmpCtx,iMngr);

        iSigCtx = tmpCtx;

        }    

    // should cert store be used        

    if ( aKeyRepository == ECertStore )

        {

        xmlSecSetCertStoreFlag();

        }

    // verify data

    if (xmlSecDSigCtxVerify(tmpCtx, INTERNAL_NODEPTR(aNode)) < 0)

        {

        if ( aKeyRepository == ECertStore )

            {

            xmlSecResetCertStoreFlag();   

            }

        XmlEngOOMTestL();

        XmlSecErrorFlagTestL();

        User::Leave(KErrVerify);

        }

    // check result

    if (tmpCtx->status == xmlSecDSigStatusSucceeded)

        {

         if ( aKeyRepository == ECertStore )

            {

            xmlSecResetCertStoreFlag();   

            }

        return ETrue;

        }

    return EFalse;

    }

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

// Verify xml node

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

//     

EXPORT_C TBool CXmlSecSign::VerifyXmlNodeKeyFromFileL(TXmlEngElement aNode,

                                                const TDesC8& aKeyFile,

                                                const TDesC8& aKeyName,

                                                TXmlSecKeyType aKeyType)

    {

    SetKeyFromFileL(aKeyFile,aKeyName,aKeyType);

    return VerifyXmlNodeL(aNode);

    }

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

// Verify xml node

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

//     

EXPORT_C TBool CXmlSecSign::VerifyXmlNodeKeyFromBufferL(TXmlEngElement aNode,

                                                  const TDesC8& aKey,

                                                  const TDesC8& aKeyName,

                                                  TXmlSecKeyType aKeyType)

    {

    SetKeyFromBufferL(aKey,aKeyName,aKeyType);

    return VerifyXmlNodeL(aNode);

    }

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

// Verify xml document

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

//     

EXPORT_C TBool CXmlSecSign::VerifyXmlDocumentL(const RXmlEngDocument& aDocument, 

                                         TXmlSecVerificationKeyRepository aKeyRepository)

    {

    xmlNodePtr node = NULL;

    TXmlEngNode tmpNode = aDocument.DocumentElement();

    xmlNodePtr root = INTERNAL_NODEPTR(tmpNode);

    node = xmlSecFindNode(root,xmlSecNodeSignature, xmlSecDSigNs);

    if(!node) 

        {

        User::Leave(KErrVerify);    

        }   

    return VerifyXmlNodeL(TXmlEngElement(node),aKeyRepository);

    }

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

// Verify xml document

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

//     

EXPORT_C TBool CXmlSecSign::VerifyXmlDocumentKeyFromFileL(const RXmlEngDocument& aDocument,

                                                    const TDesC8& aKeyFile,

                                                    const TDesC8& aKeyName,

                                                    TXmlSecKeyType aKeyType)

    {

    SetKeyFromFileL(aKeyFile,aKeyName,aKeyType);

    return VerifyXmlDocumentL(aDocument);