/** 

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

 *

 * "XML Key Management Specification v 2.0" implementation

 *  http://www.w3.org/TR/xkms2/

 * 

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

#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_soap.h"

#include "xmlsec_xkms.h"

#include "xmlsec_private.h"

#include "xmlsec_privatexkms.h"

#include "xmlsec_errors.h"

#define XMLSEC_XKMS_ID_ATTRIBUTE_LEN		32

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

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

#ifndef XMLSEC_NO_SOAP

static int      xmlSecXkmsServerCtxWriteSoap11FatalError	(xmlSecXkmsServerCtxPtr ctx,

							         xmlNodePtr envNode);

static int      xmlSecXkmsServerCtxWriteSoap12FatalError	(xmlSecXkmsServerCtxPtr ctx,

							         xmlNodePtr envNode);

#endif /* XMLSEC_NO_SOAP */

static int	xmlSecXkmsServerCtxRequestAbstractTypeNodeRead	(xmlSecXkmsServerCtxPtr ctx,

							         xmlNodePtr* node);

static int	xmlSecXkmsServerCtxSignatureNodeRead		(xmlSecXkmsServerCtxPtr ctx, 

								 xmlNodePtr node);

static int	xmlSecXkmsServerCtxMessageExtensionNodesRead	(xmlSecXkmsServerCtxPtr ctx, 

								 xmlNodePtr* node);

static int	xmlSecXkmsServerCtxOpaqueClientDataNodeRead	(xmlSecXkmsServerCtxPtr ctx, 

								 xmlNodePtr node);

static int	xmlSecXkmsServerCtxPendingNotificationNodeRead	(xmlSecXkmsServerCtxPtr ctx, 

								 xmlNodePtr node);

static int	xmlSecXkmsServerCtxRespondWithNodesRead		(xmlSecXkmsServerCtxPtr ctx, 

								 xmlNodePtr* node);

static int	xmlSecXkmsServerCtxPendingRequestNodeRead	(xmlSecXkmsServerCtxPtr ctx,

							         xmlNodePtr* node);

static int	xmlSecXkmsServerCtxQueryKeyBindingNodeRead	(xmlSecXkmsServerCtxPtr ctx,

								 xmlNodePtr node);

static int	xmlSecXkmsServerCtxKeyBindingAbstractTypeNodeRead(xmlSecXkmsServerCtxPtr ctx,

							         xmlNodePtr* node);

static int	xmlSecXkmsServerCtxKeyBindingAbstractTypeNodeWrite(xmlSecXkmsServerCtxPtr ctx,

							         xmlNodePtr node,

								 xmlSecKeyPtr key);

static int	xmlSecXkmsServerCtxKeyInfoNodeWrite		(xmlSecXkmsServerCtxPtr ctx,

							    	 xmlNodePtr node,

								 xmlSecKeyPtr key);

static int	xmlSecXkmsServerCtxUseKeyWithNodesRead		(xmlSecXkmsServerCtxPtr ctx, 

								 xmlNodePtr* node);

static int	xmlSecXkmsServerCtxUseKeyWithNodesWrite		(xmlSecXkmsServerCtxPtr ctx, 

								 xmlNodePtr node,

								 xmlSecKeyPtr key);

static int	xmlSecXkmsServerCtxTimeInstantNodeRead		(xmlSecXkmsServerCtxPtr ctx,

								 xmlNodePtr node);

static int	xmlSecXkmsServerCtxResultTypeNodeWrite		(xmlSecXkmsServerCtxPtr ctx, 

								 xmlNodePtr node);

static int	xmlSecXkmsServerCtxRequestSignatureValueNodeWrite(xmlSecXkmsServerCtxPtr ctx, 

								 xmlNodePtr node);

static int	xmlSecXkmsServerCtxUnverifiedKeyBindingNodeWrite(xmlSecXkmsServerCtxPtr ctx,

							    	 xmlNodePtr node,

								 xmlSecKeyPtr key);

static int	xmlSecXkmsServerCtxKeyBindingNodeWrite		(xmlSecXkmsServerCtxPtr ctx,

							    	 xmlNodePtr node,

								 xmlSecKeyPtr key);

static int 	xmlSecXkmsServerCtxValidityIntervalNodeWrite	(xmlSecXkmsServerCtxPtr ctx,

								 xmlNodePtr node, 

								 xmlSecKeyPtr key);

static int	xmlSecXkmsServerCtxKeyBindingStatusNodeWrite	(xmlSecXkmsServerCtxPtr ctx,

							    	 xmlNodePtr node,

								 xmlSecKeyPtr key);

static const xmlSecQName2IntegerInfo gXmlSecXkmsResultMajorInfo[] = 

{

  { xmlSecXkmsNs, xmlSecResultMajorCodeSuccess,

    xmlSecXkmsResultMajorSuccess },

  { xmlSecXkmsNs, xmlSecResultMajorCodeVersionMismatch,

    xmlSecXkmsResultMajorVersionMismatch },

  { xmlSecXkmsNs, xmlSecResultMajorCodeSender, 

    xmlSecXkmsResultMajorSender },

  { xmlSecXkmsNs, xmlSecResultMajorCodeReceiver,

    xmlSecXkmsResultMajorReceiver },

  { xmlSecXkmsNs, xmlSecResultMajorCodeRepresent,     

    xmlSecXkmsResultMajorRepresent },

  { xmlSecXkmsNs, xmlSecResultMajorCodePending, 

    xmlSecXkmsResultMajorPending, },

  { NULL , NULL, 0 }	/* MUST be last in the list */

};

static const xmlSecQName2IntegerInfo gXmlSecXkmsMinorErrorInfo[] = 

{

  { xmlSecXkmsNs, xmlSecResultMinorCodeNoMatch,

    xmlSecXkmsResultMinorNoMatch },

  { xmlSecXkmsNs, xmlSecResultMinorCodeTooManyResponses, 

    xmlSecXkmsResultMinorTooManyResponses },

  { xmlSecXkmsNs, xmlSecResultMinorCodeIncomplete,

    xmlSecXkmsResultMinorIncomplete },

  { xmlSecXkmsNs, xmlSecResultMinorCodeFailure, 

    xmlSecXkmsResultMinorFailure },

  { xmlSecXkmsNs, xmlSecResultMinorCodeRefused, 

    xmlSecXkmsResultMinorRefused },

  { xmlSecXkmsNs, xmlSecResultMinorCodeNoAuthentication, 

    xmlSecXkmsResultMinorNoAuthentication },

  { xmlSecXkmsNs, xmlSecResultMinorCodeMessageNotSupported, 

    xmlSecXkmsResultMinorMessageNotSupported },

  { xmlSecXkmsNs, xmlSecResultMinorCodeUnknownResponseId, 

    xmlSecXkmsResultMinorUnknownResponseId },

  { xmlSecXkmsNs, xmlSecResultMinorCodeNotSynchronous, 

    xmlSecXkmsResultMinorSynchronous },

  { NULL, NULL, 0 }	/* MUST be last in the list */

};

static const xmlSecQName2IntegerInfo gXmlSecXkmsKeyBindingStatusInfo[] = 

{

  { xmlSecXkmsNs, xmlSecKeyBindingStatusValid, 

    xmlSecXkmsKeyBindingStatusValid },

  { xmlSecXkmsNs, xmlSecKeyBindingStatusInvalid,

    xmlSecXkmsKeyBindingStatusInvalid },

  { xmlSecXkmsNs, xmlSecKeyBindingStatusIndeterminate, 

    xmlSecXkmsKeyBindingStatusIndeterminate },

  { NULL, NULL, 0 }	/* MUST be last in the list */

};

static const xmlSecQName2BitMaskInfo gXmlSecXkmsKeyUsageInfo[] = 

{

  { xmlSecXkmsNs, xmlSecKeyUsageEncryption,

    xmlSecKeyUsageEncrypt | xmlSecKeyUsageDecrypt },

  { xmlSecXkmsNs, xmlSecKeyUsageSignature,

    xmlSecKeyUsageSign | xmlSecKeyUsageVerify },

  { xmlSecXkmsNs, xmlSecKeyUsageExchange,

    xmlSecKeyUsageKeyExchange},

  { NULL, NULL, 0 }	/* MUST be last in the list */

};

static const xmlSecQName2BitMaskInfo gXmlSecXkmsKeyBindingReasonInfo[] = 

{

    { xmlSecXkmsNs, xmlSecKeyBindingReasonIssuerTrust,

      XMLSEC_XKMS_KEY_BINDING_REASON_MASK_ISSUER_TRAST },

    { xmlSecXkmsNs, xmlSecKeyBindingReasonRevocationStatus,

      XMLSEC_XKMS_KEY_BINDING_REASON_MASK_REVOCATION_STATUS },

    { xmlSecXkmsNs, xmlSecKeyBindingReasonValidityInterval,

      XMLSEC_XKMS_KEY_BINDING_REASON_MASK_VALIDITY_INTERVAL },

    { xmlSecXkmsNs, xmlSecKeyBindingReasonSignature,

      XMLSEC_XKMS_KEY_BINDING_REASON_MASK_SIGNATURE },

    { NULL, NULL, 0 }	/* MUST be last in the list */

};

static const xmlSecQName2BitMaskInfo gXmlSecXkmsResponseMechanismInfo[] = 

{

    { xmlSecXkmsNs, xmlSecResponseMechanismRepresent,

      XMLSEC_XKMS_RESPONSE_MECHANISM_MASK_REPRESENT },

    { xmlSecXkmsNs, xmlSecResponseMechanismPending,

      XMLSEC_XKMS_RESPONSE_MECHANISM_MASK_PENDING },

    { xmlSecXkmsNs, xmlSecResponseMechanismRequestSignatureValue,

      XMLSEC_XKMS_RESPONSE_MECHANISM_MASK_REQUEST_SIGNATURE_VALUE },

    { NULL, NULL, 0 }	/* MUST be last in the list */

};

static const xmlSecQName2IntegerInfo gXmlSecXkmsFormatInfo[] = 

{

  { NULL, xmlSecXkmsFormatStrPlain, 

    xmlSecXkmsServerFormatPlain },

#ifndef XMLSEC_NO_SOAP

  { NULL, xmlSecXkmsFormatStrSoap11,

    xmlSecXkmsServerFormatSoap11 },

  { NULL, xmlSecXkmsFormatStrSoap12, 

    xmlSecXkmsServerFormatSoap12 },

#endif /* XMLSEC_NO_SOAP */

  { NULL, NULL, 0 }	/* MUST be last in the list */

};

/**

 * xmlSecXkmsServerFormatFromString:

 * @str         the string.

 *  

 * Gets xmlSecXkmsServerFormat from string @str.

 * 

 * Returns corresponding format or xmlSecXkmsServerFormatUnknown

 * if format could not be recognized.

 */

EXPORT_C 

xmlSecXkmsServerFormat 

xmlSecXkmsServerFormatFromString(const xmlChar* str) {

    int res;

    int ret;

    xmlSecAssert2(str != NULL, xmlSecXkmsServerFormatUnknown);

    ret = xmlSecQName2IntegerGetInteger(gXmlSecXkmsFormatInfo, NULL, str, &res);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecQName2IntegerGetInteger",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(xmlSecXkmsServerFormatUnknown);   

    }

    return((xmlSecXkmsServerFormat)res);

}

/**

 * xmlSecXkmsServerFormatToString:

 * @format:     the format.

 *

 * Gets string from @format.

 *

 * Returns string corresponding to @format or NULL if an error occurs.

 */

EXPORT_C

const xmlChar* 

xmlSecXkmsServerFormatToString (xmlSecXkmsServerFormat format) {

    xmlSecQName2IntegerInfoConstPtr info;

    xmlSecAssert2(format != xmlSecXkmsServerFormatUnknown, NULL);

    info = xmlSecQName2IntegerGetInfo(gXmlSecXkmsFormatInfo, format);

    if(info == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecQName2IntegerGetInfo",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

        return(NULL);

    }

    return(info->qnameLocalPart);

}

/**

 * xmlSecXkmsServerCtxCreate:

 * @keysMngr: 	the pointer to keys manager.

 *

 * Creates XKMS request server side processing context.

 * The caller is responsible for destroying returend object by calling 

 * #xmlSecXkmsServerCtxDestroy function.

 *

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

 * occurs.

 */

EXPORT_C

xmlSecXkmsServerCtxPtr	

xmlSecXkmsServerCtxCreate(xmlSecKeysMngrPtr keysMngr) {

    xmlSecXkmsServerCtxPtr ctx;

    int ret;

    ctx = (xmlSecXkmsServerCtxPtr) xmlMalloc(sizeof(xmlSecXkmsServerCtx));

    if(ctx == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    NULL,

		    XMLSEC_ERRORS_R_MALLOC_FAILED,

		    "sizeof(xmlSecXkmsServerCtx)=%d", 

		    sizeof(xmlSecXkmsServerCtx));

	return(NULL);

    }

    ret = xmlSecXkmsServerCtxInitialize(ctx, keysMngr);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecXkmsServerCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	xmlSecXkmsServerCtxDestroy(ctx);

	return(NULL);   

    }

    return(ctx);    

}

/**

 * xmlSecXkmsServerCtxDestroy:

 * @ctx:	the pointer to XKMS processing context.

 *

 * Destroy context object created with #xmlSecXkmsServerCtxCreate function.

 */

EXPORT_C

void  

xmlSecXkmsServerCtxDestroy(xmlSecXkmsServerCtxPtr ctx) {

    xmlSecAssert(ctx != NULL);

    xmlSecXkmsServerCtxFinalize(ctx);

    xmlFree(ctx);

}

/**

 * xmlSecXkmsServerCtxInitialize:

 * @ctx:	the pointer to XKMS processing context.

 * @keysMngr: 	the pointer to keys manager.

 *

 * Initializes XKMS element processing context.

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

 * #xmlSecXkmsServerCtxFinalize function.

 *

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

 */

EXPORT_C

int 

xmlSecXkmsServerCtxInitialize(xmlSecXkmsServerCtxPtr ctx, xmlSecKeysMngrPtr keysMngr) {

    int ret;

    xmlSecAssert2(ctx != NULL, -1);

    memset(ctx, 0, sizeof(xmlSecXkmsServerCtx));

    ctx->resultMajor 	= xmlSecXkmsResultMajorSuccess;

    ctx->resultMinor 	= xmlSecXkmsResultMinorNone;

    ctx->responseLimit  = XMLSEC_XKMS_NO_RESPONSE_LIMIT;

    ctx->idLen		= XMLSEC_XKMS_ID_ATTRIBUTE_LEN;

    /* initialize key info */

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

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyInfoCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);   

    }

    ctx->keyInfoReadCtx.mode = xmlSecKeyInfoModeRead;

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

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyInfoCtxInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);   

    }

    ctx->keyInfoWriteCtx.mode = xmlSecKeyInfoModeWrite;

    /* enabled RespondWith */

    ret = xmlSecPtrListInitialize(&(ctx->enabledRespondWithIds), xmlSecXkmsRespondWithIdListId);

    if(ret < 0) { 

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    /* enabled ServerRequest */

    ret = xmlSecPtrListInitialize(&(ctx->enabledServerRequestIds), xmlSecXkmsServerRequestIdListId);

    if(ret < 0) { 

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    /* initialize keys list */

    ret = xmlSecPtrListInitialize(&(ctx->keys), xmlSecKeyPtrListId);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);   

    }

    /* initialize RespondWith list */

    ret = xmlSecPtrListInitialize(&(ctx->respWithList), xmlSecXkmsRespondWithIdListId);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);   

    }

    return(0);

}

/**

 * xmlSecXkmsServerCtxFinalize:

 * @ctx:	the pointer to XKMS processing context.

 *

 * Cleans up @ctx object.

 */

EXPORT_C

void 

xmlSecXkmsServerCtxFinalize(xmlSecXkmsServerCtxPtr ctx) {

    xmlSecAssert(ctx != NULL);

    xmlSecXkmsServerCtxReset(ctx);

    if(ctx->expectedService != NULL) {

	xmlFree(ctx->expectedService);

    }

    if(ctx->idPrefix != NULL) {

	xmlFree(ctx->idPrefix);

    }

    xmlSecKeyInfoCtxFinalize(&(ctx->keyInfoReadCtx));

    xmlSecKeyInfoCtxFinalize(&(ctx->keyInfoWriteCtx));

    xmlSecPtrListFinalize(&(ctx->enabledRespondWithIds));

    xmlSecPtrListFinalize(&(ctx->enabledServerRequestIds));

    xmlSecPtrListFinalize(&(ctx->keys));

    xmlSecPtrListFinalize(&(ctx->respWithList));

    memset(ctx, 0, sizeof(xmlSecXkmsServerCtx));

}

/**

 * xmlSecXkmsServerCtxReset:

 * @ctx:	the pointer to XKMS processing context.

 *

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

 */

EXPORT_C

void 

xmlSecXkmsServerCtxReset(xmlSecXkmsServerCtxPtr ctx) {

    xmlSecAssert(ctx != NULL);

    ctx->resultMajor = xmlSecXkmsResultMajorSuccess;

    ctx->resultMinor = xmlSecXkmsResultMinorNone;

    xmlSecKeyInfoCtxReset(&(ctx->keyInfoReadCtx));

    xmlSecKeyInfoCtxReset(&(ctx->keyInfoWriteCtx));

    xmlSecPtrListEmpty(&(ctx->keys));

    xmlSecPtrListEmpty(&(ctx->respWithList));

    ctx->requestNode            = NULL;    

    ctx->opaqueClientDataNode   = NULL;    

    ctx->firtsMsgExtNode 	= NULL;

    ctx->keyInfoNode		= NULL;

    ctx->requestId		= xmlSecXkmsServerRequestIdUnknown;

    if(ctx->id != NULL) {

	xmlFree(ctx->id); ctx->id = NULL;

    }

    if(ctx->service != NULL) {

	xmlFree(ctx->service); ctx->service = NULL;

    }

    if(ctx->nonce != NULL) {

	xmlFree(ctx->nonce); ctx->nonce = NULL;

    }

    if(ctx->originalRequestId != NULL) {

	xmlFree(ctx->originalRequestId); ctx->originalRequestId = NULL;

    }

    if(ctx->pendingNotificationMechanism != NULL) {

	xmlFree(ctx->pendingNotificationMechanism); 

	ctx->pendingNotificationMechanism = NULL;

    }

    if(ctx->pendingNotificationIdentifier != NULL) {

	xmlFree(ctx->pendingNotificationIdentifier); 

	ctx->pendingNotificationIdentifier = NULL;

    }

    if(ctx->compoundRequestContexts != NULL) {

        xmlSecPtrListDestroy(ctx->compoundRequestContexts);

        ctx->compoundRequestContexts = NULL;

    }

    ctx->responseLimit 		= XMLSEC_XKMS_NO_RESPONSE_LIMIT;

    ctx->responseMechanismMask  = 0;

}

/**

 * xmlSecXkmsServerCtxCopyUserPref:

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

xmlSecXkmsServerCtxCopyUserPref(xmlSecXkmsServerCtxPtr dst, xmlSecXkmsServerCtxPtr src) {

    int ret;

    xmlSecAssert2(dst != NULL, -1);

    xmlSecAssert2(src != NULL, -1);

    dst->userData 	= src->userData;

    dst->flags		= src->flags;

    dst->flags2		= src->flags2;

    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);