/** 

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

 *

 * Keys.

 *

 * 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_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_list.h"

#include "xmlsec_keys.h"

#include "xmlsec_keysmngr.h"

#include "xmlsec_transforms.h"

#include "xmlsec_keyinfo.h"

#include "xmlsec_errors.h"

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

 *

 * xmlSecKeyUseWith

 *

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

/** 

 * xmlSecKeyUseWithInitialize:

 * @keyUseWith:         the pointer to information about key application/user.

 * 

 * Initializes @keyUseWith object.

 *

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

 */

EXPORT_C

int 

xmlSecKeyUseWithInitialize(xmlSecKeyUseWithPtr keyUseWith) {

    xmlSecAssert2(keyUseWith != NULL, -1);

    memset(keyUseWith, 0, sizeof(xmlSecKeyUseWith));

    return(0);

}

/** 

 * xmlSecKeyUseWithFinalize:

 * @keyUseWith:         the pointer to information about key application/user.

 *

 * Finalizes @keyUseWith object.

 */

EXPORT_C

void 

xmlSecKeyUseWithFinalize(xmlSecKeyUseWithPtr keyUseWith) {

    xmlSecAssert(keyUseWith != NULL);

    xmlSecKeyUseWithReset(keyUseWith);

    memset(keyUseWith, 0, sizeof(xmlSecKeyUseWith));

}

/** 

 * xmlSecKeyUseWithReset:

 * @keyUseWith:         the pointer to information about key application/user.

 * 

 * Resets the @keyUseWith to its state after initialization.

 */

EXPORT_C

void 

xmlSecKeyUseWithReset(xmlSecKeyUseWithPtr keyUseWith) {

    xmlSecAssert(keyUseWith != NULL);

    xmlSecKeyUseWithSet(keyUseWith, NULL, NULL);

}

/** 

 * xmlSecKeyUseWithCopy:

 * @dst:         the pointer to destination object.

 * @src:         the pointer to source object.

 *

 * Copies information from @dst to @src.

 *

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

 */

EXPORT_C

int 

xmlSecKeyUseWithCopy(xmlSecKeyUseWithPtr dst, xmlSecKeyUseWithPtr src) {

    xmlSecAssert2(dst != NULL, -1);

    xmlSecAssert2(src != NULL, -1);

    return(xmlSecKeyUseWithSet(dst, src->application, src->identifier));

}

/** 

 * xmlSecKeyUseWithCreate:

 * @keyUseWith:         the pointer to information about key application/user.

 * @application:        the application value.

 * @identifier:         the identifier value.

 *

 * Creates new xmlSecKeyUseWith object. The caller is responsible for destroying

 * returned object with @xmlSecKeyUseWithDestroy function.

 *

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

 */

EXPORT_C

xmlSecKeyUseWithPtr 

xmlSecKeyUseWithCreate(const xmlChar* application, const xmlChar* identifier) {

    xmlSecKeyUseWithPtr keyUseWith;

    int ret;

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

    keyUseWith = (xmlSecKeyUseWithPtr)xmlMalloc(sizeof(xmlSecKeyUseWith));

    if(keyUseWith == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    NULL,

		    XMLSEC_ERRORS_R_MALLOC_FAILED,

		    "sizeof(xmlSecKeyUseWith)=%d", 

		    sizeof(xmlSecKeyUseWith));

	return(NULL);

    }

    memset(keyUseWith, 0, sizeof(xmlSecKeyUseWith));    

    ret = xmlSecKeyUseWithInitialize(keyUseWith);

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyUseWithInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

        xmlSecKeyUseWithDestroy(keyUseWith);

        return(NULL);        

    }

    ret = xmlSecKeyUseWithSet(keyUseWith, application, identifier);

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyUseWithSet",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

        xmlSecKeyUseWithDestroy(keyUseWith);

        return(NULL);        

    }

    return(keyUseWith);

}

/** 

 * xmlSecKeyUseWithDuplicate:

 * @keyUseWith:         the pointer to information about key application/user.

 *

 * Duplicates @keyUseWith object. The caller is responsible for destroying

 * returned object with @xmlSecKeyUseWithDestroy function.

 *

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

 */

EXPORT_C

xmlSecKeyUseWithPtr 

xmlSecKeyUseWithDuplicate(xmlSecKeyUseWithPtr keyUseWith) {

    int ret;

    xmlSecKeyUseWithPtr newKeyUseWith;

    xmlSecAssert2(keyUseWith != NULL, NULL);

    newKeyUseWith = xmlSecKeyUseWithCreate(NULL, NULL);

    if(newKeyUseWith == NULL) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyUseWithCreate",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

        return(NULL);        

    }

    ret = xmlSecKeyUseWithCopy(newKeyUseWith, keyUseWith);

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyUseWithCopy",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

        xmlSecKeyUseWithDestroy(keyUseWith);

        return(NULL);        

    }

    return(newKeyUseWith);

}

/** 

 * xmlSecKeyUseWithDestroy:

 * @keyUseWith:         the pointer to information about key application/user.

 *

 * Destroys @keyUseWith created with @xmlSecKeyUseWithCreate or @xmlSecKeyUseWithDuplicate

 * functions.

 */

EXPORT_C

void 

xmlSecKeyUseWithDestroy(xmlSecKeyUseWithPtr keyUseWith) {

    xmlSecAssert(keyUseWith != NULL);

    xmlSecKeyUseWithFinalize(keyUseWith);

    xmlFree(keyUseWith);

}

/** 

 * xmlSecKeyUseWithSet:

 * @keyUseWith:         the pointer to information about key application/user.

 * @application:        the new application value.

 * @identifier:         the new identifier value.

 * 

 * Sets @application and @identifier in the @keyUseWith.

 *

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

 */

EXPORT_C

int 

xmlSecKeyUseWithSet(xmlSecKeyUseWithPtr keyUseWith, const xmlChar* application, const xmlChar* identifier) {

    xmlSecAssert2(keyUseWith != NULL, -1);

    if(keyUseWith->application != NULL) {

	xmlFree(keyUseWith->application); 

	keyUseWith->application = NULL;

    }

    if(keyUseWith->identifier != NULL) {

	xmlFree(keyUseWith->identifier); 

	keyUseWith->identifier = NULL;

    }

    if(application != NULL) {

	keyUseWith->application = xmlStrdup(application);

	if(keyUseWith->application == NULL) {

    	    xmlSecError(XMLSEC_ERRORS_HERE,

		        NULL,

			NULL,

		        XMLSEC_ERRORS_R_MALLOC_FAILED,

			"xmlStrlen(application)=%d", 

			xmlStrlen(application));

	    return(-1);

	}

    }

    if(identifier != NULL) {

	keyUseWith->identifier = xmlStrdup(identifier);

	if(keyUseWith->identifier == NULL) {

    	    xmlSecError(XMLSEC_ERRORS_HERE,

		        NULL,

			NULL,

		        XMLSEC_ERRORS_R_MALLOC_FAILED,

			"xmlStrlen(identifier)=%d", 

			xmlStrlen(identifier));

	    return(-1);

	}

    }

    return(0);

}

/** 

 * xmlSecKeyUseWithDebugDump:

 * @keyUseWith:         the pointer to information about key application/user.

 * @output:             the pointer to output FILE.

 *

 * Prints xmlSecKeyUseWith debug information to a file @output.

 */

EXPORT_C

void 

xmlSecKeyUseWithDebugDump(xmlSecKeyUseWithPtr keyUseWith, FILE* output) {

    xmlSecAssert(keyUseWith != NULL);

    xmlSecAssert(output != NULL);

    fprintf(output, "=== KeyUseWith: application=\"%s\",identifier=\"%s\"\n", 

                (keyUseWith->application) ? keyUseWith->application : BAD_CAST "",

                (keyUseWith->identifier) ? keyUseWith->identifier : BAD_CAST "");    

}

/** 

 * xmlSecKeyUseWithDebugXmlDump:

 * @keyUseWith:         the pointer to information about key application/user.

 * @output:             the pointer to output FILE.

 *

 * Prints xmlSecKeyUseWith debug information to a file @output in XML format.

 */

EXPORT_C

void 

xmlSecKeyUseWithDebugXmlDump(xmlSecKeyUseWithPtr keyUseWith, FILE* output) {

    xmlSecAssert(keyUseWith != NULL);

    xmlSecAssert(output != NULL);

    fprintf(output, "<KeyUseWith>\n");

    fprintf(output, "<Application>%s</Application>", 

        (keyUseWith->application) ? keyUseWith->application : BAD_CAST "");

    fprintf(output, "<Identifier>%s</Identifier>", 

        (keyUseWith->identifier) ? keyUseWith->identifier : BAD_CAST "");

    fprintf(output, "</KeyUseWith>\n");

}

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

 *

 * KeyUseWith list

 *

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

static xmlSecPtrListKlass xmlSecKeyUseWithPtrListKlass = {

    BAD_CAST "key-use-with-list",

    (xmlSecPtrDuplicateItemMethod)xmlSecKeyUseWithDuplicate, 	/* xmlSecPtrDuplicateItemMethod duplicateItem; */

    (xmlSecPtrDestroyItemMethod)xmlSecKeyUseWithDestroy,	/* xmlSecPtrDestroyItemMethod destroyItem; */

    (xmlSecPtrDebugDumpItemMethod)xmlSecKeyUseWithDebugDump,	/* xmlSecPtrDebugDumpItemMethod debugDumpItem; */

    (xmlSecPtrDebugDumpItemMethod)xmlSecKeyUseWithDebugXmlDump,	/* xmlSecPtrDebugDumpItemMethod debugXmlDumpItem; */

};

/**

 * xmlSecKeyUseWithPtrListGetKlass:

 * 

 * The key data list klass.

 *

 * Returns pointer to the key data list klass.

 */

EXPORT_C

xmlSecPtrListId 

xmlSecKeyUseWithPtrListGetKlass(void) {

    return(&xmlSecKeyUseWithPtrListKlass);

}

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

 *

 * xmlSecKeyReq - what key are we looking for?

 *

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

/** 

 * xmlSecKeyReqInitialize:

 * @keyReq:		the pointer to key requirements object.

 *

 * Initialize key requirements object. Caller is responsible for

 * cleaning it with #xmlSecKeyReqFinalize function.

 *

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

 */

EXPORT_C

int 

xmlSecKeyReqInitialize(xmlSecKeyReqPtr keyReq) {

    int ret;

    xmlSecAssert2(keyReq != NULL, -1);

    memset(keyReq, 0, sizeof(xmlSecKeyReq));

    keyReq->keyUsage	= xmlSecKeyUsageAny;	/* by default you can do whatever you want with the key */

    ret = xmlSecPtrListInitialize(&keyReq->keyUseWithList, xmlSecKeyUseWithPtrListId);    

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    return(0);

}

/**

 * xmlSecKeyReqFinalize:

 * @keyReq:		the pointer to key requirements object.

 *

 * Cleans the key requirements object initialized with #xmlSecKeyReqInitialize

 * function.

 */

EXPORT_C

void

xmlSecKeyReqFinalize(xmlSecKeyReqPtr keyReq) {

    xmlSecAssert(keyReq != NULL);

    xmlSecPtrListFinalize(&keyReq->keyUseWithList);    

    memset(keyReq, 0, sizeof(xmlSecKeyReq));

}

/** 

 * xmlSecKeyReqReset:

 * @keyReq:		the pointer to key requirements object.

 *

 * Resets key requirements object for new key search.

 */

EXPORT_C

void 

xmlSecKeyReqReset(xmlSecKeyReqPtr keyReq) {

    xmlSecAssert(keyReq != NULL);

    xmlSecPtrListEmpty(&keyReq->keyUseWithList);

    keyReq->keyId	= NULL;

    keyReq->keyType	= 0;

    keyReq->keyUsage	= xmlSecKeyUsageAny;

    keyReq->keyBitsSize	= 0;

}

/**

 * xmlSecKeyReqCopy:

 * @dst:		the pointer to destination object.

 * @src:		the pointer to source object.

 *

 * Copies key requirements from @src object to @dst object.

 * 

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

 */

EXPORT_C

int 

xmlSecKeyReqCopy(xmlSecKeyReqPtr dst, xmlSecKeyReqPtr src) {

    int ret;

    xmlSecAssert2(dst != NULL, -1);

    xmlSecAssert2(src != NULL, -1);

    dst->keyId		= src->keyId;

    dst->keyType	= src->keyType;

    dst->keyUsage	= src->keyUsage;

    dst->keyBitsSize	= src->keyBitsSize;

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

    if(ret < 0) {

    	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListCopy",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);

    }

    return(0);

}

/**

 * xmlSecKeyReqMatchKey:

 * @keyReq:		the pointer to key requirements object.

 * @key:		the pointer to key.

 *

 * Checks whether @key matches key requirements @keyReq.

 *

 * Returns 1 if key matches requirements, 0 if not and a negative value

 * if an error occurs.

 */

EXPORT_C

int 

xmlSecKeyReqMatchKey(xmlSecKeyReqPtr keyReq, xmlSecKeyPtr key) {

    xmlSecAssert2(keyReq != NULL, -1);

    xmlSecAssert2(xmlSecKeyIsValid(key), -1);

    if((keyReq->keyType != xmlSecKeyDataTypeUnknown) && ((xmlSecKeyGetType(key) & keyReq->keyType) == 0)) {

	 return(0);

    }

    if((keyReq->keyUsage != xmlSecKeyDataUsageUnknown) && ((keyReq->keyUsage & key->usage) == 0)) {

	return(0);

    }

    return(xmlSecKeyReqMatchKeyValue(keyReq, xmlSecKeyGetValue(key)));

}

/**

 * xmlSecKeyReqMatchKeyValue:

 * @keyReq:		the pointer to key requirements.

 * @value:		the pointer to key value.

 *

 * Checks whether @keyValue matches key requirements @keyReq.

 *

 * Returns 1 if key value matches requirements, 0 if not and a negative value

 * if an error occurs.

 */

EXPORT_C

int 

xmlSecKeyReqMatchKeyValue(xmlSecKeyReqPtr keyReq, xmlSecKeyDataPtr value) {

    xmlSecAssert2(keyReq != NULL, -1);

    xmlSecAssert2(value != NULL, -1);

    if((keyReq->keyId != xmlSecKeyDataIdUnknown) && 

       (!xmlSecKeyDataCheckId(value, keyReq->keyId))) {

	return(0);

    }

    if((keyReq->keyBitsSize > 0) && 

       (xmlSecKeyDataGetSize(value) > 0) && 

       (xmlSecKeyDataGetSize(value) < keyReq->keyBitsSize)) {

	return(0);

    }

    return(1);

}

/** 

 * xmlSecKeyReqDebugDump:

 * @keyReq:		the pointer to key requirements object.

 * @output: 		the pointer to output FILE.

 *

 * Prints debug information about @keyReq into @output.

 */

EXPORT_C 

void 

xmlSecKeyReqDebugDump(xmlSecKeyReqPtr keyReq, FILE* output) {

    xmlSecAssert(keyReq != NULL);

    xmlSecAssert(output != NULL);

    fprintf(output, "=== KeyReq:\n");

    fprintf(output, "==== keyId: %s\n", 

	    (xmlSecKeyDataKlassGetName(keyReq->keyId)) ? 

		xmlSecKeyDataKlassGetName(keyReq->keyId) : 

		BAD_CAST "NULL");

    fprintf(output, "==== keyType: 0x%08x\n", keyReq->keyType);

    fprintf(output, "==== keyUsage: 0x%08x\n", keyReq->keyUsage);

    fprintf(output, "==== keyBitsSize: %d\n", keyReq->keyBitsSize);

    xmlSecPtrListDebugDump(&(keyReq->keyUseWithList), output);

}

/** 

 * xmlSecKeyReqDebugXmlDump:

 * @keyReq:		the pointer to key requirements object.

 * @output: 		the pointer to output FILE.

 *

 * Prints debug information about @keyReq into @output in XML format.

 */

EXPORT_C 

void 

xmlSecKeyReqDebugXmlDump(xmlSecKeyReqPtr keyReq, FILE* output) {

    xmlSecAssert(keyReq != NULL);

    xmlSecAssert(output != NULL);

    fprintf(output, "<KeyReq>\n");