/** 

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

 *

 * "XML Encryption" implementation

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

 * 

 * 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_XMLENC

#include "xmlsec_globals.h"

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <libxml2_tree.h>

#include <libxml2_parser.h>

#include <libxml2_globals.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_keyinfo.h"

#include "xmlsec_xmlenc.h"

#include "xmlsec_errors.h"

static int 	xmlSecEncCtxEncDataNodeRead		(xmlSecEncCtxPtr encCtx, 

							 xmlNodePtr node);

static int 	xmlSecEncCtxEncDataNodeWrite		(xmlSecEncCtxPtr encCtx);

static int 	xmlSecEncCtxCipherDataNodeRead		(xmlSecEncCtxPtr encCtx, 

							 xmlNodePtr node);

static int 	xmlSecEncCtxCipherReferenceNodeRead	(xmlSecEncCtxPtr encCtx, 

							 xmlNodePtr node);

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

static const xmlChar*		xmlSecEncIds[] = { BAD_CAST "Id", NULL };

/**

 * xmlSecEncCtxCreate:

 * @keysMngr: 		the pointer to keys manager.

 *

 * Creates <enc:EncryptedData/> element processing context.

 * The caller is responsible for destroying returend object by calling 

 * #xmlSecEncCtxDestroy function.

 *

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

 * occurs.

 */

EXPORT_C

xmlSecEncCtxPtr	

xmlSecEncCtxCreate(xmlSecKeysMngrPtr keysMngr) {

    xmlSecEncCtxPtr encCtx;

    int ret;

    encCtx = (xmlSecEncCtxPtr) xmlMalloc(sizeof(xmlSecEncCtx));

    if(encCtx == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    NULL,

		    XMLSEC_ERRORS_R_MALLOC_FAILED,

		    "sizeof(xmlSecEncCtx)=%d", 

		    sizeof(xmlSecEncCtx));

	return(NULL);

    }

    ret = xmlSecEncCtxInitialize(encCtx, keysMngr);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecEncCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	xmlSecEncCtxDestroy(encCtx);

	return(NULL);   

    }

    return(encCtx);    

}

/**

 * xmlSecEncCtxDestroy:

 * @encCtx:		the pointer to <enc:EncryptedData/> processing context.

 *

 * Destroy context object created with #xmlSecEncCtxCreate function.

 */

EXPORT_C

void  

xmlSecEncCtxDestroy(xmlSecEncCtxPtr encCtx) {

    xmlSecAssert(encCtx != NULL);

    xmlSecEncCtxFinalize(encCtx);

    xmlFree(encCtx);

}

/**

 * xmlSecEncCtxInitialize:

 * @encCtx:		the pointer to <enc:EncryptedData/> processing context.

 * @keysMngr: 		the pointer to keys manager.

 *

 * Initializes <enc:EncryptedData/> element processing context.

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

 * #xmlSecEncCtxFinalize function.

 *

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

 */

EXPORT_C

int 

xmlSecEncCtxInitialize(xmlSecEncCtxPtr encCtx, xmlSecKeysMngrPtr keysMngr) {

    int ret;

    xmlSecAssert2(encCtx != NULL, -1);

    memset(encCtx, 0, sizeof(xmlSecEncCtx));

    /* initialize key info */

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

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyInfoCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);   

    }

    encCtx->keyInfoReadCtx.mode = xmlSecKeyInfoModeRead;

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

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyInfoCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);   

    }

    encCtx->keyInfoWriteCtx.mode = xmlSecKeyInfoModeWrite;

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

    encCtx->keyInfoWriteCtx.keyReq.keyType = xmlSecKeyDataTypePublic;

    /* initializes transforms encCtx */

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

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);   

    }

    return(0);

}

/**

 * xmlSecEncCtxFinalize:

 * @encCtx:		the pointer to <enc:EncryptedData/> processing context.

 *

 * Cleans up @encCtx object.

 */

EXPORT_C

void 

xmlSecEncCtxFinalize(xmlSecEncCtxPtr encCtx) {

    xmlSecAssert(encCtx != NULL);

    xmlSecEncCtxReset(encCtx);

    xmlSecTransformCtxFinalize(&(encCtx->transformCtx));

    xmlSecKeyInfoCtxFinalize(&(encCtx->keyInfoReadCtx));

    xmlSecKeyInfoCtxFinalize(&(encCtx->keyInfoWriteCtx));

    memset(encCtx, 0, sizeof(xmlSecEncCtx));

}

/**

 * xmlSecEncCtxReset:

 * @encCtx:		the pointer to <enc:EncryptedData/> processing context.

 *

 * Resets @encCtx object, user settings are not touched.

 */

EXPORT_C

void 

xmlSecEncCtxReset(xmlSecEncCtxPtr encCtx) {

    xmlSecAssert(encCtx != NULL);

    xmlSecTransformCtxReset(&(encCtx->transformCtx));

    xmlSecKeyInfoCtxReset(&(encCtx->keyInfoReadCtx));

    xmlSecKeyInfoCtxReset(&(encCtx->keyInfoWriteCtx));

    encCtx->operation 		= xmlSecTransformOperationNone;

    encCtx->result		= NULL;

    encCtx->resultBase64Encoded = 0;

    encCtx->resultReplaced	= 0;

    encCtx->encMethod		= NULL;

    if(encCtx->encKey != NULL) {

	xmlSecKeyDestroy(encCtx->encKey);

	encCtx->encKey = NULL;

    }

    if(encCtx->id != NULL) {

	xmlFree(encCtx->id);

	encCtx->id = NULL;

    }	

    if(encCtx->type != NULL) {

	xmlFree(encCtx->type);

	encCtx->type = NULL;

    }

    if(encCtx->mimeType != NULL) {

	xmlFree(encCtx->mimeType);

	encCtx->mimeType = NULL;

    }

    if(encCtx->encoding != NULL) {

	xmlFree(encCtx->encoding);

	encCtx->encoding = NULL;

    }	

    if(encCtx->recipient != NULL) {

	xmlFree(encCtx->recipient);

	encCtx->recipient = NULL;

    }

    if(encCtx->carriedKeyName != NULL) {

	xmlFree(encCtx->carriedKeyName);

	encCtx->carriedKeyName = NULL;

    }

    encCtx->encDataNode = encCtx->encMethodNode = 

	encCtx->keyInfoNode = encCtx->cipherValueNode = NULL;

}

/**

 * xmlSecEncCtxCopyUserPref:

 * @dst:		the pointer to destination context.

 * @src:		the pointer to source context.

 * 

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

 *

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

 */

EXPORT_C

int 

xmlSecEncCtxCopyUserPref(xmlSecEncCtxPtr dst, xmlSecEncCtxPtr src) {

    int ret;

    xmlSecAssert2(dst != NULL, -1);

    xmlSecAssert2(src != NULL, -1);

    dst->userData 	= src->userData;

    dst->flags		= src->flags;

    dst->flags2		= src->flags2;

    dst->defEncMethodId = src->defEncMethodId;

    dst->mode 		= src->mode;

    ret = xmlSecTransformCtxCopyUserPref(&(dst->transformCtx), &(src->transformCtx));

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformCtxCopyUserPref",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    ret = xmlSecKeyInfoCtxCopyUserPref(&(dst->keyInfoReadCtx), &(src->keyInfoReadCtx));

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyInfoCtxCopyUserPref",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    ret = xmlSecKeyInfoCtxCopyUserPref(&(dst->keyInfoWriteCtx), &(src->keyInfoWriteCtx));

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyInfoCtxCopyUserPref",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    return(0);

} 

/**

 * xmlSecEncCtxBinaryEncrypt:

 * @encCtx:		the pointer to <enc:EncryptedData/> processing context.

 * @tmpl:		the pointer to <enc:EncryptedData/> template node.

 * @data:		the pointer for binary buffer.

 * @dataSize:		the @data buffer size.

 *

 * Encrypts @data according to template @tmpl.

 *

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

 */

EXPORT_C

int 

xmlSecEncCtxBinaryEncrypt(xmlSecEncCtxPtr encCtx, xmlNodePtr tmpl, 

			  const xmlSecByte* data, xmlSecSize dataSize) {

    int ret;

    xmlSecAssert2(encCtx != NULL, -1);

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

    xmlSecAssert2(tmpl != NULL, -1);

    xmlSecAssert2(data != NULL, -1);

    /* initialize context and add ID atributes to the list of known ids */    

    encCtx->operation = xmlSecTransformOperationEncrypt;

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

    /* read the template and set encryption method, key, etc. */

    ret = xmlSecEncCtxEncDataNodeRead(encCtx, tmpl);

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecEncCtxEncDataNodeRead",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    ret = xmlSecTransformCtxBinaryExecute(&(encCtx->transformCtx), data, dataSize);

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformCtxBinaryExecute",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "dataSize=%d",

		    dataSize);

	return(-1);

    }

    encCtx->result = encCtx->transformCtx.result;

    xmlSecAssert2(encCtx->result != NULL, -1);

    ret = xmlSecEncCtxEncDataNodeWrite(encCtx);

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecEncCtxEncDataNodeWrite",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    return(0);    

}

/**

 * xmlSecEncCtxXmlEncrypt:

 * @encCtx:		the pointer to <enc:EncryptedData/> processing context.

 * @tmpl:		the pointer to <enc:EncryptedData/> template node.

 * @node:		the pointer to node for encryption.

 *

 * Encrypts @node according to template @tmpl. If requested, @node is replaced

 * with result <enc:EncryptedData/> node.

 *

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

 */

EXPORT_C

int 

xmlSecEncCtxXmlEncrypt(xmlSecEncCtxPtr encCtx, xmlNodePtr tmpl, xmlNodePtr node) {

    xmlOutputBufferPtr output;

    int ret;

    xmlSecAssert2(encCtx != NULL, -1);

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

    xmlSecAssert2(tmpl != NULL, -1);

    xmlSecAssert2(node != NULL, -1);

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

    /* initialize context and add ID atributes to the list of known ids */    

    encCtx->operation = xmlSecTransformOperationEncrypt;

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

    /* read the template and set encryption method, key, etc. */

    ret = xmlSecEncCtxEncDataNodeRead(encCtx, tmpl);

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecEncCtxEncDataNodeRead",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    ret = xmlSecTransformCtxPrepare(&(encCtx->transformCtx), xmlSecTransformDataTypeBin);

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformCtxPrepare",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "type=bin");

	return(-1);

    }

    xmlSecAssert2(encCtx->transformCtx.first != NULL, -1);

    output = xmlSecTransformCreateOutputBuffer(encCtx->transformCtx.first, 

						&(encCtx->transformCtx));

    if(output == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    xmlSecErrorsSafeString(xmlSecTransformGetName(encCtx->transformCtx.first)),

		    "xmlSecTransformCreateOutputBuffer",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    /* push data thru */

    if((encCtx->type != NULL) && xmlStrEqual(encCtx->type, xmlSecTypeEncElement)) {

	/* get the content of the node */

	xmlNodeDumpOutput(output, node->doc, node, 0, 0, NULL);

    } else if((encCtx->type != NULL) && xmlStrEqual(encCtx->type, xmlSecTypeEncContent)) {

	xmlNodePtr cur;

	/* get the content of the nodes childs */

	for(cur = node->children; cur != NULL; cur = cur->next) {

	    xmlNodeDumpOutput(output, node->doc, cur, 0, 0, NULL);

	}

    } else {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    NULL,

		    XMLSEC_ERRORS_R_INVALID_TYPE,

		    "type=%s", 

		    xmlSecErrorsSafeString(encCtx->type));

	xmlOutputBufferClose(output);

	return(-1);	    	

    }

    /* close the buffer and flush everything */

    ret = xmlOutputBufferClose(output);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlOutputBufferClose",

		    XMLSEC_ERRORS_R_XML_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    encCtx->result = encCtx->transformCtx.result;

    xmlSecAssert2(encCtx->result != NULL, -1);

    ret = xmlSecEncCtxEncDataNodeWrite(encCtx);

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecEncCtxEncDataNodeWrite",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    /* now we need to update our original document */

    if((encCtx->type != NULL) && xmlStrEqual(encCtx->type, xmlSecTypeEncElement)) {

	ret = xmlSecReplaceNode(node, tmpl);

	if(ret < 0) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

			NULL,

			"xmlSecReplaceNode",

			XMLSEC_ERRORS_R_XMLSEC_FAILED,

			"node=%s",

			xmlSecErrorsSafeString(xmlSecNodeGetName(node)));

	    return(-1);

	}

	encCtx->resultReplaced = 1;			       

    } else if((encCtx->type != NULL) && xmlStrEqual(encCtx->type, xmlSecTypeEncContent)) {

	ret = xmlSecReplaceContent(node, tmpl);

	if(ret < 0) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

			NULL,

			"xmlSecReplaceContent",

			XMLSEC_ERRORS_R_XMLSEC_FAILED,

			"node=%s",

			xmlSecErrorsSafeString(xmlSecNodeGetName(node)));

	    return(-1);

	}

	encCtx->resultReplaced = 1;			       

    } else {

	/* we should've catached this error before */

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    NULL,

		    XMLSEC_ERRORS_R_INVALID_TYPE,

		    "type=%s", 

		    xmlSecErrorsSafeString(encCtx->type));

	return(-1);	    	

    }

    return(0);    

}

/**

 * xmlSecEncCtxUriEncrypt:

 * @encCtx:		the pointer to <enc:EncryptedData/> processing context.

 * @tmpl:		the pointer to <enc:EncryptedData/> template node.

 * @uri:		the URI.

 *

 * Encrypts data from @uri according to template @tmpl.

 *

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

 */

EXPORT_C

int 

xmlSecEncCtxUriEncrypt(xmlSecEncCtxPtr encCtx, xmlNodePtr tmpl, const xmlChar *uri) {

    int ret;

    xmlSecAssert2(encCtx != NULL, -1);

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

    xmlSecAssert2(tmpl != NULL, -1);

    xmlSecAssert2(uri != NULL, -1);

    /* initialize context and add ID atributes to the list of known ids */    

    encCtx->operation = xmlSecTransformOperationEncrypt;

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

    /* we need to add input uri transform first */

    ret = xmlSecTransformCtxSetUri(&(encCtx->transformCtx), uri, tmpl);

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecTransformCtxSetUri",