/** 

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

 *

 * "XML Digital Signature" implementation

 *  http://www.w3.org/TR/xmldsig-core/

 *  http://www.w3.org/Signature/Overview.html

 * 

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

 * distribution for preciese wording.

 * 

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

 * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 */

#include "xmlsec_config.h"

#ifndef XMLSEC_NO_XMLDSIG

#include "xmlsec_globals.h"

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include "xmlsec_xmlsec.h"

#include "xmlsec_buffer.h"

#include "xmlsec_xmltree.h"

#include "xmlsec_keys.h"

#include "xmlsec_keysmngr.h"

#include "xmlsec_transforms.h"

#include "xmlsec_membuf.h"

#include "xmlsec_xmldsig.h"

#include "xmlsec_errors.h"

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

 *

 * xmlSecDSigCtx

 *

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

static int	xmlSecDSigCtxProcessSignatureNode	(xmlSecDSigCtxPtr dsigCtx, 

							 xmlNodePtr node);

static int	xmlSecDSigCtxProcessSignedInfoNode	(xmlSecDSigCtxPtr dsigCtx, 

							 xmlNodePtr node);

static int	xmlSecDSigCtxProcessKeyInfoNode		(xmlSecDSigCtxPtr dsigCtx, 

							 xmlNodePtr node);

static int	xmlSecDSigCtxProcessObjectNode		(xmlSecDSigCtxPtr dsigCtx, 

							 xmlNodePtr node);

static int	xmlSecDSigCtxProcessManifestNode	(xmlSecDSigCtxPtr dsigCtx, 

							 xmlNodePtr node);

/* The ID attribute in XMLDSig is 'Id' */

static const xmlChar*		xmlSecDSigIds[] = { xmlSecAttrId, NULL };

/**

 * xmlSecDSigCtxCreate:

 * @keysMngr: 		the pointer to keys manager.

 *

 * Creates <dsig:Signature/> element processing context.

 * The caller is responsible for destroying returend object by calling 

 * #xmlSecDSigCtxDestroy function.

 *

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

 * occurs.

 */

EXPORT_C

xmlSecDSigCtxPtr	

xmlSecDSigCtxCreate(xmlSecKeysMngrPtr keysMngr) {

    xmlSecDSigCtxPtr dsigCtx;

    int ret;

    dsigCtx = (xmlSecDSigCtxPtr) xmlMalloc(sizeof(xmlSecDSigCtx));

    if(dsigCtx == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    NULL,

		    XMLSEC_ERRORS_R_MALLOC_FAILED,

		    "sizeof(xmlSecDSigCtx)=%d", 

		    sizeof(xmlSecDSigCtx));

	return(NULL);

    }

    ret = xmlSecDSigCtxInitialize(dsigCtx, keysMngr);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecDSigCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	xmlSecDSigCtxDestroy(dsigCtx);

	return(NULL);   

    }

    return(dsigCtx);    

}

/**

 * xmlSecDSigCtxDestroy:

 * @dsigCtx:		the pointer to <dsig:Signature/> processing context.

 *

 * Destroy context object created with #xmlSecDSigCtxCreate function.

 */

EXPORT_C

void  

xmlSecDSigCtxDestroy(xmlSecDSigCtxPtr dsigCtx) {

    xmlSecAssert(dsigCtx != NULL);

    xmlSecDSigCtxFinalize(dsigCtx);

    xmlFree(dsigCtx);

}

/**

 * xmlSecDSigCtxInitialize:

 * @dsigCtx:		the pointer to <dsig:Signature/> processing context.

 * @keysMngr: 		the pointer to keys manager.

 *

 * Initializes <dsig:Signature/> element processing context.

 * The caller is responsible for cleaing up returend object by calling 

 * #xmlSecDSigCtxFinalize function.

 *

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

 */

EXPORT_C

int 

xmlSecDSigCtxInitialize(xmlSecDSigCtxPtr dsigCtx, xmlSecKeysMngrPtr keysMngr) {

    int ret,ret1;

    xmlSecAssert2(dsigCtx != NULL, -1);

    memset(dsigCtx, 0, sizeof(xmlSecDSigCtx));

    /* initialize key info */

    ret = xmlSecKeyInfoCtxInitialize(&(dsigCtx->keyInfoReadCtx), keysMngr);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyInfoCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);   

    }

    dsigCtx->keyInfoReadCtx.mode = xmlSecKeyInfoModeRead;

    ret = xmlSecKeyInfoCtxInitialize(&(dsigCtx->keyInfoWriteCtx), keysMngr);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyInfoCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);   

    }

    dsigCtx->keyInfoWriteCtx.mode = xmlSecKeyInfoModeWrite;

    /* it's not wise to write private key :) */

    dsigCtx->keyInfoWriteCtx.keyReq.keyType = xmlSecKeyDataTypePublic;

    /* initializes transforms dsigCtx */

    ret = xmlSecTransformCtxInitialize(&(dsigCtx->transformCtx));

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);   

    }

    /* references lists from SignedInfo and Manifest elements */

    ret=xmlSecPtrListInitialize(&(dsigCtx->signedInfoReferences), 

			    xmlSecDSigReferenceCtxListId);

    ret1=xmlSecPtrListInitialize(&(dsigCtx->manifestReferences), 

			    xmlSecDSigReferenceCtxListId);    

    if(ret<0 ||ret1<0)

        {

        xmlSecError(XMLSEC_ERRORS_HERE,

                NULL,

                "xmlSecTransformCtxInitialize",

                XMLSEC_ERRORS_R_XMLSEC_FAILED,

                XMLSEC_ERRORS_NO_MESSAGE);

        return(-1);   

        }

    dsigCtx->enabledReferenceUris = xmlSecTransformUriTypeAny;

    return(0);

}

/**

 * xmlSecDSigCtxFinalize:

 * @dsigCtx:		the pointer to <dsig:Signature/> processing context.

 *

 * Cleans up @dsigCtx object initialized with #xmlSecDSigCtxInitialize function.

 */

EXPORT_C

void 

xmlSecDSigCtxFinalize(xmlSecDSigCtxPtr dsigCtx) {

    xmlSecAssert(dsigCtx != NULL);

    xmlSecTransformCtxFinalize(&(dsigCtx->transformCtx));

    xmlSecKeyInfoCtxFinalize(&(dsigCtx->keyInfoReadCtx));

    xmlSecKeyInfoCtxFinalize(&(dsigCtx->keyInfoWriteCtx));

    xmlSecPtrListFinalize(&(dsigCtx->signedInfoReferences));

    xmlSecPtrListFinalize(&(dsigCtx->manifestReferences));

    if(dsigCtx->enabledReferenceTransforms != NULL) {

	xmlSecPtrListDestroy(dsigCtx->enabledReferenceTransforms);	

    }

    if(dsigCtx->signKey != NULL) {

	xmlSecKeyDestroy(dsigCtx->signKey);

    }

    if(dsigCtx->id != NULL) {

	xmlFree(dsigCtx->id);

    }	

    memset(dsigCtx, 0, sizeof(xmlSecDSigCtx));

}

/**

 * xmlSecDSigCtxEnableReferenceTransform:

 * @dsigCtx:		the pointer to <dsig:Signature/> processing context.

 * @transformId:	the transform klass.

 *

 * Enables @transformId for <dsig:Reference/> elements processing.

 *

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

 */

EXPORT_C

int 

xmlSecDSigCtxEnableReferenceTransform(xmlSecDSigCtxPtr dsigCtx, xmlSecTransformId transformId) {

    int ret;

    xmlSecAssert2(dsigCtx != NULL, -1);

    xmlSecAssert2(dsigCtx->result == NULL, -1);

    xmlSecAssert2(transformId != xmlSecTransformIdUnknown, -1);

    if(dsigCtx->enabledReferenceTransforms == NULL) {

	dsigCtx->enabledReferenceTransforms = xmlSecPtrListCreate(xmlSecTransformIdListId);

	if(dsigCtx->enabledReferenceTransforms == NULL) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

			NULL,

			"xmlSecPtrListCreate",

			XMLSEC_ERRORS_R_XMLSEC_FAILED,

			XMLSEC_ERRORS_NO_MESSAGE);

	    return(-1);   

	}

    }	

    ret = xmlSecPtrListAdd(dsigCtx->enabledReferenceTransforms, (void*)transformId);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListAdd",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);   

    }

    return(0);

}

/**

 * xmlSecDSigCtxEnableSignatureTransform:

 * @dsigCtx:		the pointer to <dsig:Signature/> processing context.

 * @transformId:	the transform klass.

 *

 * Enables @transformId for <dsig:SignedInfo/> element processing.

 *

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

 */

EXPORT_C

int 

xmlSecDSigCtxEnableSignatureTransform(xmlSecDSigCtxPtr dsigCtx, xmlSecTransformId transformId) {

    xmlSecAssert2(dsigCtx != NULL, -1);

    xmlSecAssert2(dsigCtx->result == NULL, -1);

    xmlSecAssert2(transformId != xmlSecTransformIdUnknown, -1);

    return(xmlSecPtrListAdd(&(dsigCtx->transformCtx.enabledTransforms), (void*)transformId));

}

/**

 * xmlSecDSigCtxGetPreSignBuffer:

 * @dsigCtx:		the pointer to <dsig:Signature/> processing context.

 * 

 * Gets pointer to the buffer with serialized <dsig:SignedInfo/> element

 * just before signature claculation (valid if and only if 

 * #XMLSEC_DSIG_FLAGS_STORE_SIGNATURE context flag is set.

 *

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

 */

EXPORT_C

xmlSecBufferPtr 

xmlSecDSigCtxGetPreSignBuffer(xmlSecDSigCtxPtr dsigCtx) {

    xmlSecAssert2(dsigCtx != NULL, NULL);

    return((dsigCtx->preSignMemBufMethod != NULL) ? 

	    xmlSecTransformMemBufGetBuffer(dsigCtx->preSignMemBufMethod) : NULL);

}

/**

 * xmlSecDSigCtxSign:

 * @dsigCtx:		the pointer to <dsig:Signature/> processing context.

 * @tmpl:		the pointer to <dsig:Signature/> node with signature template.

 *

 * Signs the data as described in @tmpl node.

 *

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

 */

EXPORT_C

int 

xmlSecDSigCtxSign(xmlSecDSigCtxPtr dsigCtx, xmlNodePtr tmpl) {

    int ret;

    xmlSecAssert2(dsigCtx != NULL, -1);

    xmlSecAssert2(dsigCtx->result == NULL, -1);

    xmlSecAssert2(tmpl != NULL, -1);

    xmlSecAssert2(tmpl->doc != NULL, -1);

    /* add ids for Signature nodes */

    dsigCtx->operation 	= xmlSecTransformOperationSign;

    dsigCtx->status 	= xmlSecDSigStatusUnknown;

    xmlSecAddIDs(tmpl->doc, tmpl, xmlSecDSigIds);

    /* read signature template */

    ret = xmlSecDSigCtxProcessSignatureNode(dsigCtx, tmpl);

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecDSigCtxSigantureProcessNode",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    xmlSecAssert2(dsigCtx->signMethod != NULL, -1);

    xmlSecAssert2(dsigCtx->signValueNode != NULL, -1);

    /* references processing might change the status */

    if(dsigCtx->status != xmlSecDSigStatusUnknown) {

	return(0);

    }

    /* check what we've got */

    dsigCtx->result = dsigCtx->transformCtx.result;

    if((dsigCtx->result == NULL) || (xmlSecBufferGetData(dsigCtx->result) == NULL)) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    NULL,

		    XMLSEC_ERRORS_R_INVALID_RESULT,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    /* write signed data to xml */

    xmlNodeSetContentLen(dsigCtx->signValueNode,

			    xmlSecBufferGetData(dsigCtx->result),

			    xmlSecBufferGetSize(dsigCtx->result));

    if ( OOM_FLAG )

        {

        return(-1);

        }

    /* set success status and we are done */

    dsigCtx->status = xmlSecDSigStatusSucceeded;

    return(0);    

}

/**

 * xmlSecDSigCtxVerify:

 * @dsigCtx:		the pointer to <dsig:Signature/> processing context.

 * @node:		the pointer with <dsig:Signature/> node.

 * 

 * Vaidates signature in the @node. The verification result is returned

 * in #status member of the @dsigCtx object.

 *

 * Returns 0 on success (check #status member of @dsigCtx to get 

 * signature verification result) or a negative value if an error occurs.

 */

EXPORT_C

int 

xmlSecDSigCtxVerify(xmlSecDSigCtxPtr dsigCtx, xmlNodePtr node) {

    int ret;

    xmlSecAssert2(dsigCtx != NULL, -1);

    xmlSecAssert2(node != NULL, -1);

    xmlSecAssert2(node->doc != NULL, -1);

    /* add ids for Signature nodes */

    dsigCtx->operation 	= xmlSecTransformOperationVerify;

    dsigCtx->status 	= xmlSecDSigStatusUnknown;

    xmlSecAddIDs(node->doc, node, xmlSecDSigIds);

    /* read siganture info */

    ret = xmlSecDSigCtxProcessSignatureNode(dsigCtx, node);

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecDSigCtxSigantureProcessNode",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    xmlSecAssert2(dsigCtx->signMethod != NULL, -1);

    xmlSecAssert2(dsigCtx->signValueNode != NULL, -1);

    /* references processing might change the status */

    if(dsigCtx->status != xmlSecDSigStatusUnknown) {

	return(0);

    }

    /* verify SignatureValue node content */

    ret = xmlSecTransformVerifyNodeContent(dsigCtx->signMethod, dsigCtx->signValueNode,

					   &(dsigCtx->transformCtx));

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformVerifyNodeContent",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    /* set status and we are done */

    if(dsigCtx->signMethod->status == xmlSecTransformStatusOk) {

        dsigCtx->status = xmlSecDSigStatusSucceeded;

    } else {

        dsigCtx->status = xmlSecDSigStatusInvalid;

    }

    return(0);

}

/**

 * xmlSecDSigCtxProcessSignatureNode:

 *

 * The Signature  element (http://www.w3.org/TR/xmldsig-core/#sec-Signature)

 *

 * The Signature element is the root element of an XML Signature. 

 * Implementation MUST generate laxly schema valid [XML-schema] Signature 

 * elements as specified by the following schema:

 * The way in which the SignedInfo element is presented to the 

 * canonicalization method is dependent on that method. The following 

 * applies to algorithms which process XML as nodes or characters:

 *

 *  - XML based canonicalization implementations MUST be provided with 

 *  a [XPath] node-set originally formed from the document containing 

 *  the SignedInfo and currently indicating the SignedInfo, its descendants,

 *  and the attribute and namespace nodes of SignedInfo and its descendant 

 *  elements.

 *

 *  - Text based canonicalization algorithms (such as CRLF and charset 

 *  normalization) should be provided with the UTF-8 octets that represent 

 *  the well-formed SignedInfo element, from the first character to the 

 *  last character of the XML representation, inclusive. This includes 

 *  the entire text of the start and end tags of the SignedInfo element 

 *  as well as all descendant markup and character data (i.e., the text) 

 *  between those tags. Use of text based canonicalization of SignedInfo 

 *  is NOT RECOMMENDED.   	     

 *

 *  =================================

 *  we do not support any non XML based C14N 

 *

 * Schema Definition:

 *

 *  <element name="Signature" type="ds:SignatureType"/>

 *  <complexType name="SignatureType">

 *  <sequence> 

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

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

 *     <element ref="ds:KeyInfo" minOccurs="0"/> 

 *     <element ref="ds:Object" minOccurs="0" maxOccurs="unbounded"/> 

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

 *  </complexType>

 *    

 * DTD:

 *    

 *  <!ELEMENT Signature (SignedInfo, SignatureValue, KeyInfo?, Object*)  >

 *  <!ATTLIST Signature  

 *      xmlns   CDATA   #FIXED 'http://www.w3.org/2000/09/xmldsig#'

 *      Id      ID  #IMPLIED >

 *

 */

static int

xmlSecDSigCtxProcessSignatureNode(xmlSecDSigCtxPtr dsigCtx, xmlNodePtr node) {

    xmlSecTransformDataType firstType;

    xmlNodePtr signedInfoNode = NULL;

    xmlNodePtr keyInfoNode = NULL;

    xmlNodePtr cur;

    int ret;

    xmlSecAssert2(dsigCtx != NULL, -1);

    xmlSecAssert2((dsigCtx->operation == xmlSecTransformOperationSign) || (dsigCtx->operation == xmlSecTransformOperationVerify), -1);

    xmlSecAssert2(dsigCtx->status == xmlSecDSigStatusUnknown, -1);

    xmlSecAssert2(dsigCtx->signValueNode == NULL, -1);

    xmlSecAssert2(dsigCtx->signMethod == NULL, -1);

    xmlSecAssert2(dsigCtx->c14nMethod == NULL, -1);

    xmlSecAssert2(node != NULL, -1);

    if(!xmlSecCheckNodeName(node, xmlSecNodeSignature, xmlSecDSigNs)) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    xmlSecErrorsSafeString(xmlSecNodeGetName(node)),

		    XMLSEC_ERRORS_R_INVALID_NODE,

		    "expected=%s",

		    xmlSecErrorsSafeString(xmlSecNodeSignature));

	return(-1);	    

    }

    /* read node data */

    xmlSecAssert2(dsigCtx->id == NULL, -1);

    dsigCtx->id = xmlGetProp(node, xmlSecAttrId);

    /* first node is required SignedInfo */

    cur = xmlSecGetNextElementNode(node->children);    

    if((cur == NULL) || (!xmlSecCheckNodeName(cur, xmlSecNodeSignedInfo, xmlSecDSigNs))) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),

		    XMLSEC_ERRORS_R_INVALID_NODE,

		    "expected=%s",

		    xmlSecErrorsSafeString(xmlSecNodeSignedInfo));

        return(-1);

    }

    signedInfoNode = cur;

    cur = xmlSecGetNextElementNode(cur->next);

    /* next node is required SignatureValue */

    if((cur == NULL) || (!xmlSecCheckNodeName(cur, xmlSecNodeSignatureValue, xmlSecDSigNs))) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),

		    XMLSEC_ERRORS_R_INVALID_NODE,

		    "expected=%s",

		    xmlSecErrorsSafeString(xmlSecNodeSignatureValue));