/** 

 * XML Security Library (http://www.aleksey.com/xmlsec).

 *

 * <dsig:KeyInfo/> element processing 

 * (http://www.w3.org/TR/xmlSec-core/#sec-KeyInfo:

 *

 * The KeyInfo Element

 *

 * KeyInfo is an optional element that enables the recipient(s) to obtain 

 * the key needed to validate the signature.  KeyInfo may contain keys, 

 * names, certificates and other public key management information, such as 

 * in-band key distribution or key agreement data. 

 * 

 *  Schema Definition:

 *

 *  <element name="KeyInfo" type="ds:KeyInfoType"/> 

 *  <complexType name="KeyInfoType" mixed="true">

 *    <choice maxOccurs="unbounded"> 

 *       <element ref="ds:KeyName"/> 

 *       <element ref="ds:KeyValue"/> 

 *       <element ref="ds:RetrievalMethod"/> 

 *       <element ref="ds:X509Data"/> 

 *       <element ref="ds:PGPData"/> 

 *       <element ref="ds:SPKIData"/>

 *       <element ref="ds:MgmtData"/>

 *       <any processContents="lax" namespace="##other"/>

 *       <!-- (1,1) elements from (0,unbounded) namespaces -->

 *    </choice>

 *    <attribute name="Id" type="ID" use="optional"/>

 *  </complexType>

 *    

 * DTD:

 *    

 * <!ELEMENT KeyInfo (#PCDATA|KeyName|KeyValue|RetrievalMethod|

 *                    X509Data|PGPData|SPKIData|MgmtData %KeyInfo.ANY;)* >      

 * <!ATTLIST KeyInfo  Id  ID   #IMPLIED >

 *  

 *

 * This is free software; see Copyright file in the source

 * distribution for preciese wording.

 * 

 * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>

 */

#include "xmlsec_globals.h"

#include <stdlib.h>

#include <string.h>

#include <libxml2_tree.h>

#include <libxml2_globals.h>

#include "xmlsec_xmlsec.h"

#include "xmlsec_xmltree.h"

#include "xmlsec_base64.h"

#include "xmlsec_keys.h"

#include "xmlsec_keysmngr.h"

#include "xmlsec_transforms.h"

#include "xmlsec_xmlenc.h"

#include "xmlsec_keyinfo.h"

#include "xmlsec_errors.h"

/**************************************************************************

 *

 * Hi level functions

 *

 *************************************************************************/

/**

 * xmlSecKeyInfoNodeRead:

 * @keyInfoNode: 	the pointer to <dsig:KeyInfo/> node.

 * @key:		the pointer to result key object.

 * @keyInfoCtx:		the pointer to <dsig:KeyInfo/> element processing context.

 *

 * Parses the <dsig:KeyInfo/> element @keyInfoNode, extracts the key data

 * and stores into @key.

 *

 * Returns 0 on success or -1 if an error occurs.

 */

EXPORT_C

int

xmlSecKeyInfoNodeRead(xmlNodePtr keyInfoNode, xmlSecKeyPtr key, xmlSecKeyInfoCtxPtr keyInfoCtx) {

    const xmlChar* nodeName;

    const xmlChar* nodeNs;

    xmlSecKeyDataId dataId;

    xmlNodePtr cur;

    int ret;

    xmlSecAssert2(keyInfoNode != NULL, -1);

    xmlSecAssert2(key != NULL, -1);

    xmlSecAssert2(keyInfoCtx != NULL, -1);

    xmlSecAssert2(keyInfoCtx->mode == xmlSecKeyInfoModeRead, -1);

    for(cur = xmlSecGetNextElementNode(keyInfoNode->children); 

	(cur != NULL) && 

	(((keyInfoCtx->flags & XMLSEC_KEYINFO_FLAGS_DONT_STOP_ON_KEY_FOUND) != 0) || 

	 (xmlSecKeyIsValid(key) == 0) || 

	 (xmlSecKeyMatch(key, NULL, &(keyInfoCtx->keyReq)) == 0));

	cur = xmlSecGetNextElementNode(cur->next)) {

	/* find data id */

	nodeName = cur->name;

	nodeNs = xmlSecGetNodeNsHref(cur);

	/* use global list only if we don't have a local one */

	if(xmlSecPtrListGetSize(&(keyInfoCtx->enabledKeyData)) > 0) {

	    dataId = xmlSecKeyDataIdListFindByNode(&(keyInfoCtx->enabledKeyData),

			    nodeName, nodeNs, xmlSecKeyDataUsageKeyInfoNodeRead);

	} else {	

    	    dataId = xmlSecKeyDataIdListFindByNode(xmlSecKeyDataIdsGet(),

			    nodeName, nodeNs, xmlSecKeyDataUsageKeyInfoNodeRead);

	}

	if(dataId != xmlSecKeyDataIdUnknown) {

	    /* read data node */

	    ret = xmlSecKeyDataXmlRead(dataId, key, cur, keyInfoCtx);

	    if(ret < 0) {

		xmlSecError(XMLSEC_ERRORS_HERE,

			    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(dataId)),

			    "xmlSecKeyDataXmlRead",

			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

			    "node=%s", 

			    xmlSecErrorsSafeString(xmlSecNodeGetName(cur)));

		return(-1);

	    }

	} else if((keyInfoCtx->flags & XMLSEC_KEYINFO_FLAGS_STOP_ON_UNKNOWN_CHILD) != 0) {

	    /* there is a laxi schema validation but application may

	     * desire to disable unknown nodes*/

	    xmlSecError(XMLSEC_ERRORS_HERE,

			NULL,

			xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),

			XMLSEC_ERRORS_R_INVALID_NODE,

			XMLSEC_ERRORS_NO_MESSAGE);

	    return(-1);

	}

    }

    return(0);    

}

/**

 * xmlSecKeyInfoNodeWrite:

 * @keyInfoNode: 	the pointer to <dsig:KeyInfo/> node.

 * @key:		the pointer to key object.

 * @keyInfoCtx:		the pointer to <dsig:KeyInfo/> element processing context.

 *

 * Writes the @key into the <dsig:KeyInfo/> element template @keyInfoNode.

 *

 * Returns 0 on success or -1 if an error occurs.

 */

EXPORT_C

int 

xmlSecKeyInfoNodeWrite(xmlNodePtr keyInfoNode, xmlSecKeyPtr key, xmlSecKeyInfoCtxPtr keyInfoCtx) {

    const xmlChar* nodeName;

    const xmlChar* nodeNs;

    xmlSecKeyDataId dataId;

    xmlNodePtr cur;

    int ret;

    xmlSecAssert2(keyInfoNode != NULL, -1);

    xmlSecAssert2(key != NULL, -1);

    xmlSecAssert2(keyInfoCtx != NULL, -1);

    xmlSecAssert2(keyInfoCtx->mode == xmlSecKeyInfoModeWrite, -1);

    for(cur = xmlSecGetNextElementNode(keyInfoNode->children); 

	cur != NULL;

	cur = xmlSecGetNextElementNode(cur->next)) {

	/* find data id */

	nodeName = cur->name;

	nodeNs = xmlSecGetNodeNsHref(cur);

	/* use global list only if we don't have a local one */

	if(xmlSecPtrListGetSize(&(keyInfoCtx->enabledKeyData)) > 0) {

        	dataId = xmlSecKeyDataIdListFindByNode(&(keyInfoCtx->enabledKeyData),

			    nodeName, nodeNs, 

			    xmlSecKeyDataUsageKeyInfoNodeWrite);

	} else {

        	dataId = xmlSecKeyDataIdListFindByNode(xmlSecKeyDataIdsGet(),

			    nodeName, nodeNs, 

			    xmlSecKeyDataUsageKeyInfoNodeWrite);

	}

	if(dataId != xmlSecKeyDataIdUnknown) {

	    ret = xmlSecKeyDataXmlWrite(dataId, key, cur, keyInfoCtx);

	    if(ret < 0) {

		xmlSecError(XMLSEC_ERRORS_HERE,

			    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(dataId)),

			    "xmlSecKeyDataXmlWrite",

			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

			    "node=%s", 

			    xmlSecErrorsSafeString(xmlSecNodeGetName(cur)));

		return(-1);

	    }

	} else if((keyInfoCtx->flags & XMLSEC_KEYINFO_FLAGS_STOP_ON_UNKNOWN_CHILD) != 0) {

	    /* laxi schema validation but application can disable it*/

	    xmlSecError(XMLSEC_ERRORS_HERE,

			NULL,

			xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),

			XMLSEC_ERRORS_R_INVALID_NODE,

			XMLSEC_ERRORS_NO_MESSAGE);

	    return(-1);

	}

    }

    return(0);

} 

/**************************************************************************

 *

 * KeyInfo context

 *

 *************************************************************************/

/**

 * xmlSecKeyInfoCtxCreate:

 * @keysMngr: 		the pointer to keys manager (may be NULL).

 *

 * Allocates and initializes <dsig:KeyInfo/> element processing context.

 * Caller is responsible for freeing it by calling #xmlSecKeyInfoCtxDestroy 

 * function.

 *

 * Returns pointer to newly allocated object or NULL if an error occurs.

 */

EXPORT_C

xmlSecKeyInfoCtxPtr 

xmlSecKeyInfoCtxCreate(xmlSecKeysMngrPtr keysMngr) {

    xmlSecKeyInfoCtxPtr keyInfoCtx;

    int ret;

    /* Allocate a new xmlSecKeyInfoCtx and fill the fields. */

    keyInfoCtx = (xmlSecKeyInfoCtxPtr)xmlMalloc(sizeof(xmlSecKeyInfoCtx));

    if(keyInfoCtx == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    NULL,

		    XMLSEC_ERRORS_R_MALLOC_FAILED,

		    "size=%d", sizeof(xmlSecKeyInfoCtx)); 

	return(NULL);

    }

    ret = xmlSecKeyInfoCtxInitialize(keyInfoCtx, keysMngr);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyInfoCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	xmlSecKeyInfoCtxDestroy(keyInfoCtx);

	return(NULL);

    }

    return(keyInfoCtx);

}

/** 

 * xmlSecKeyInfoCtxDestroy:

 * @keyInfoCtx:		the pointer to <dsig:KeyInfo/> element processing context.

 *

 * Destroys @keyInfoCtx object created with #xmlSecKeyInfoCtxCreate function.

 */

EXPORT_C

void 

xmlSecKeyInfoCtxDestroy(xmlSecKeyInfoCtxPtr keyInfoCtx) {

    xmlSecAssert(keyInfoCtx != NULL);

    xmlSecKeyInfoCtxFinalize(keyInfoCtx);

    xmlFree(keyInfoCtx);

}

/** 

 * xmlSecKeyInfoCtxInitialize:

 * @keyInfoCtx:		the pointer to <dsig:KeyInfo/> element processing context.

 * @keysMngr: 		the pointer to keys manager (may be NULL).

 *

 * Initializes <dsig:KeyInfo/> element processing context. Caller is 

 * responsible for cleaning it up by #xmlSecKeyInfoCtxFinalize function.

 * 

 * Returns 0 on success and a negative value if an error occurs.

 */

EXPORT_C

int 

xmlSecKeyInfoCtxInitialize(xmlSecKeyInfoCtxPtr keyInfoCtx, xmlSecKeysMngrPtr keysMngr) {

    int ret;

    xmlSecAssert2(keyInfoCtx != NULL, -1);

    memset(keyInfoCtx, 0, sizeof(xmlSecKeyInfoCtx));

    keyInfoCtx->keysMngr = keysMngr;

    keyInfoCtx->base64LineSize = XMLSEC_BASE64_LINESIZE;    

    ret = xmlSecPtrListInitialize(&(keyInfoCtx->enabledKeyData), xmlSecKeyDataIdListId);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    keyInfoCtx->maxRetrievalMethodLevel = 1;

    ret = xmlSecTransformCtxInitialize(&(keyInfoCtx->retrievalMethodCtx));

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

#ifndef XMLSEC_NO_XMLENC

    keyInfoCtx->maxEncryptedKeyLevel = 1;

#endif /* XMLSEC_NO_XMLENC */

#ifndef XMLSEC_NO_X509

    keyInfoCtx->certsVerificationDepth= 9;

#endif /* XMLSEC_NO_X509 */

    ret = xmlSecKeyReqInitialize(&(keyInfoCtx->keyReq));

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyReqInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    return(0);

}

/** 

 * xmlSecKeyInfoCtxFinalize:

 * @keyInfoCtx:		the pointer to <dsig:KeyInfo/> element processing context.

 *

 * Cleans up the @keyInfoCtx initialized with #xmlSecKeyInfoCtxInitialize

 * function.

 */

EXPORT_C

void 

xmlSecKeyInfoCtxFinalize(xmlSecKeyInfoCtxPtr keyInfoCtx) {

    xmlSecAssert(keyInfoCtx != NULL);

    xmlSecPtrListFinalize(&(keyInfoCtx->enabledKeyData));

    xmlSecTransformCtxFinalize(&(keyInfoCtx->retrievalMethodCtx));

    xmlSecKeyReqFinalize(&(keyInfoCtx->keyReq));

#ifndef XMLSEC_NO_XMLENC

    if(keyInfoCtx->encCtx != NULL) {

        xmlSecEncCtxDestroy(keyInfoCtx->encCtx);

    }

#endif /* XMLSEC_NO_XMLENC */

    memset(keyInfoCtx, 0, sizeof(xmlSecKeyInfoCtx));

}

/** 

 * xmlSecKeyInfoCtxReset:

 * @keyInfoCtx:		the pointer to <dsig:KeyInfo/> element processing context.

 * 

 * Resets the @keyInfoCtx state. User settings are not changed.

 */

EXPORT_C

void 

xmlSecKeyInfoCtxReset(xmlSecKeyInfoCtxPtr keyInfoCtx) {

    xmlSecAssert(keyInfoCtx != NULL);

    xmlSecTransformCtxReset(&(keyInfoCtx->retrievalMethodCtx));

    keyInfoCtx->curRetrievalMethodLevel = 0;

#ifndef XMLSEC_NO_XMLENC

    if(keyInfoCtx->encCtx != NULL) { 	   

        xmlSecEncCtxReset(keyInfoCtx->encCtx);

    }

    keyInfoCtx->curEncryptedKeyLevel = 0;

#endif /* XMLSEC_NO_XMLENC */

    xmlSecKeyReqReset(&(keyInfoCtx->keyReq));

}

/** 

 * xmlSecKeyInfoCtxCreateEncCtx:

 * @keyInfoCtx:		the pointer to <dsig:KeyInfo/> element processing context.

 * 

 * Creates encryption context form processing <enc:EncryptedKey/> child

 * of <dsig:KeyInfo/> element.

 * 

 * Returns 0 on success and a negative value if an error occurs.

 */

EXPORT_C

int 

xmlSecKeyInfoCtxCreateEncCtx(xmlSecKeyInfoCtxPtr keyInfoCtx) {

#ifndef XMLSEC_NO_XMLENC

    xmlSecEncCtxPtr tmp;

    int ret;

    xmlSecAssert2(keyInfoCtx != NULL, -1);

    xmlSecAssert2(keyInfoCtx->encCtx == NULL, -1);

    /* we have to use tmp variable to avoid a recursive loop */ 

    tmp = xmlSecEncCtxCreate(keyInfoCtx->keysMngr);

    if(tmp == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecEncCtxCreate",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    tmp->mode = xmlEncCtxModeEncryptedKey;

    /* copy user preferences from our current ctx */

    switch(keyInfoCtx->mode) {

	case xmlSecKeyInfoModeRead:

	    ret = xmlSecKeyInfoCtxCopyUserPref(&(tmp->keyInfoReadCtx), keyInfoCtx);

	    if(ret < 0) {

		xmlSecError(XMLSEC_ERRORS_HERE,

			    NULL,

			    "xmlSecKeyInfoCtxCopyUserPref",

			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

			    XMLSEC_ERRORS_NO_MESSAGE);

		xmlSecEncCtxDestroy(tmp);

		return(-1);

	    }    

	    break;

	case xmlSecKeyInfoModeWrite:

	    ret = xmlSecKeyInfoCtxCopyUserPref(&(tmp->keyInfoWriteCtx), keyInfoCtx);

	    if(ret < 0) {

		xmlSecError(XMLSEC_ERRORS_HERE,

			    NULL,

			    "xmlSecKeyInfoCtxCopyUserPref",

			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

			    XMLSEC_ERRORS_NO_MESSAGE);

		xmlSecEncCtxDestroy(tmp);

		return(-1);

	    }

	    break;

    }    

    keyInfoCtx->encCtx = tmp;

    return(0);

#else /* XMLSEC_NO_XMLENC */    

    xmlSecError(XMLSEC_ERRORS_HERE,

		NULL,

		"xml encryption",

		XMLSEC_ERRORS_R_DISABLED,

		XMLSEC_ERRORS_NO_MESSAGE);

    return(-1);

#endif /* XMLSEC_NO_XMLENC */    

}

/** 

 * xmlSecKeyInfoCtxCopyUserPref:

 * @dst:		the pointer to destination context object.

 * @src:		the pointer to source context object.

 *

 * Copies user preferences from @src context to @dst context.

 *  

 * Returns 0 on success and a negative value if an error occurs.

 */

EXPORT_C

int 

xmlSecKeyInfoCtxCopyUserPref(xmlSecKeyInfoCtxPtr dst, xmlSecKeyInfoCtxPtr src) {

    int ret;

    xmlSecAssert2(dst != NULL, -1);

    xmlSecAssert2(src != NULL, -1);

    dst->userData 	= src->userData;

    dst->flags		= src->flags;

    dst->flags2		= src->flags2;

    dst->keysMngr	= src->keysMngr;

    dst->mode		= src->mode;

    dst->base64LineSize	= src->base64LineSize;

    ret = xmlSecPtrListCopy(&(dst->enabledKeyData), &(src->enabledKeyData));

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListCopy",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "enabledKeyData");    

	return(-1);

    }

    /* <dsig:RetrievalMethod/> */

    dst->maxRetrievalMethodLevel= src->maxRetrievalMethodLevel;

    ret = xmlSecTransformCtxCopyUserPref(&(dst->retrievalMethodCtx), 

					 &(src->retrievalMethodCtx));

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformCtxCopyUserPref",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "enabledKeyData");    

	return(-1);

    }

    /* <enc:EncryptedContext /> */    

#ifndef XMLSEC_NO_XMLENC

    xmlSecAssert2(dst->encCtx == NULL, -1);

    if(src->encCtx != NULL) { 	   	

	dst->encCtx = xmlSecEncCtxCreate(dst->keysMngr);

	if(dst->encCtx == NULL) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

		        NULL,

			"xmlSecEncCtxCreate",

		        XMLSEC_ERRORS_R_XMLSEC_FAILED,

		        XMLSEC_ERRORS_NO_MESSAGE);

	    return(-1);

	}

	dst->encCtx->mode = xmlEncCtxModeEncryptedKey;

        ret = xmlSecEncCtxCopyUserPref(dst->encCtx, src->encCtx);

	if(ret < 0) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

		        NULL,

			"xmlSecEncCtxCopyUserPref",

		        XMLSEC_ERRORS_R_XMLSEC_FAILED,

		        XMLSEC_ERRORS_NO_MESSAGE);

	    return(-1);

	}

    }

    dst->maxEncryptedKeyLevel	= src->maxEncryptedKeyLevel;

#endif /* XMLSEC_NO_XMLENC */

    /* <dsig:X509Data /> */    

#ifndef XMLSEC_NO_X509

    dst->certsVerificationTime	= src->certsVerificationTime;

    dst->certsVerificationDepth	= src->certsVerificationDepth;

#endif /* XMLSEC_NO_X509 */