/** 

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

 *

 * Key data.

 *

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

#include "xmlsec_keyinfo.h"

#include "xmlsec_transforms.h"

#include "xmlsec_base64.h"

#include "xmlsec_keyinfo.h"

#include "xmlsec_errors.h"

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

 *

 * Global xmlSecKeyDataIds list functions

 *

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

static xmlSecPtrList xmlSecAllKeyDataIds;

/** 

 * xmlSecKeyDataIdsGet:

 *

 * Gets global registered key data klasses list.

 * 

 * Returns the pointer to list of all registered key data klasses.

 */

EXPORT_C

xmlSecPtrListPtr

xmlSecKeyDataIdsGet(void) {

    return(&xmlSecAllKeyDataIds);

}

/** 

 * xmlSecKeyDataIdsInit:

 *

 * Initializes the key data klasses. This function is called from the 

 * #xmlSecInit function and the application should not call it directly.

 *

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

 */

EXPORT_C

int 

xmlSecKeyDataIdsInit(void) {

    int ret;

    ret = xmlSecPtrListInitialize(xmlSecKeyDataIdsGet(), xmlSecKeyDataIdListId);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListPtrInitialize",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "xmlSecKeyDataIdListId");

        return(-1);

    }

    ret = xmlSecKeyDataIdsRegisterDefault();

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyDataIdsRegisterDefault",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

        return(-1);

    }

    return(0);

}

/**

 * xmlSecKeyDataIdsShutdown:

 * 

 * Shuts down the keys data klasses. This function is called from the 

 * #xmlSecShutdown function and the application should not call it directly.

 */

EXPORT_C

void

xmlSecKeyDataIdsShutdown(void) {

    xmlSecPtrListFinalize(xmlSecKeyDataIdsGet());

}

/** 

 * xmlSecKeyDataIdsRegister:

 * @id:			the key data klass.

 *

 * Registers @id in the global list of key data klasses.

 *

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

 */

EXPORT_C

int 

xmlSecKeyDataIdsRegister(xmlSecKeyDataId id) {

    int ret;

    xmlSecAssert2(id != xmlSecKeyDataIdUnknown, -1);

    ret = xmlSecPtrListAdd(xmlSecKeyDataIdsGet(), (xmlSecPtr)id);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecPtrListAdd",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "dataId=%s",

		    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)));

        return(-1);

    }

    return(0);    

}

/**

 * xmlSecKeyDataIdsRegisterDefault:

 *

 * Registers default (implemented by XML Security Library)

 * key data klasses: <dsig:KeyName/> element processing klass, 

 * <dsig:KeyValue/> element processing klass, ...

 *

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

 */

EXPORT_C

int 

xmlSecKeyDataIdsRegisterDefault(void) {

    if(xmlSecKeyDataIdsRegister(xmlSecKeyDataNameId) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyDataIdsRegister",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "xmlSecKeyDataNameId");

        return(-1);	

    }

    if(xmlSecKeyDataIdsRegister(xmlSecKeyDataValueId) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyDataIdsRegister",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "xmlSecKeyDataValueId");

        return(-1);	

    }

    if(xmlSecKeyDataIdsRegister(xmlSecKeyDataRetrievalMethodId) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyDataIdsRegister",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "xmlSecKeyDataRetrievalMethodId");

        return(-1);	

    }

#ifndef XMLSEC_NO_XMLENC

    if(xmlSecKeyDataIdsRegister(xmlSecKeyDataEncryptedKeyId) < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyDataIdsRegister",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "xmlSecKeyDataEncryptedKeyId");

        return(-1);	

    }

#endif /* XMLSEC_NO_XMLENC */

    return(0);

}

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

 *

 * xmlSecKeyData functions

 *

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

/**

 * xmlSecKeyDataCreate:

 * @id: 		the data id.

 *

 * Allocates and initializes new key data of the specified type @id.

 * Caller is responsible for destroing returend object with 

 * #xmlSecKeyDataDestroy function.

 *

 * Returns the pointer to newly allocated key data structure

 * or NULL if an error occurs.

 */

EXPORT_C

xmlSecKeyDataPtr	

xmlSecKeyDataCreate(xmlSecKeyDataId id)  {

    xmlSecKeyDataPtr data;

    int ret;

    xmlSecAssert2(id != NULL, NULL);

    xmlSecAssert2(id->klassSize >= sizeof(xmlSecKeyDataKlass), NULL);

    xmlSecAssert2(id->objSize >= sizeof(xmlSecKeyData), NULL);

    xmlSecAssert2(id->name != NULL, NULL);

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

    data = (xmlSecKeyDataPtr)xmlMalloc(id->objSize);

    if(data == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

		    NULL,

		    XMLSEC_ERRORS_R_MALLOC_FAILED,

		    "size=%d", id->objSize); 

	return(NULL);

    }

    memset(data, 0, id->objSize);    

    data->id = id;

    if(id->initialize != NULL) {

	ret = (id->initialize)(data);

        if(ret < 0) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

			xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

			"id->initialize",

			XMLSEC_ERRORS_R_XMLSEC_FAILED,

			XMLSEC_ERRORS_NO_MESSAGE);

	    xmlSecKeyDataDestroy(data);

	    return(NULL);

	}

    }

    return(data);

}

/**

 * xmlSecKeyDataDuplicate:

 * @data: 		the pointer to the key data.

 *

 * Creates a duplicate of the given @data. Caller is responsible for 

 * destroing returend object with #xmlSecKeyDataDestroy function.

 *

 * Returns the pointer to newly allocated key data structure

 * or NULL if an error occurs.

 */

EXPORT_C

xmlSecKeyDataPtr	

xmlSecKeyDataDuplicate(xmlSecKeyDataPtr data) {

    xmlSecKeyDataPtr newData;

    int ret;

    xmlSecAssert2(xmlSecKeyDataIsValid(data), NULL);

    xmlSecAssert2(data->id->duplicate != NULL, NULL);

    newData = xmlSecKeyDataCreate(data->id);

    if(newData == NULL) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

		    "xmlSecKeyDataCreate",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE); 

	return(NULL);

    }

    ret = (data->id->duplicate)(newData, data);

    if(newData == NULL || ret<0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

		    "id->duplicate",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	xmlSecKeyDataDestroy(newData);

	return(NULL);	

    }

    xmlSecKeyDataDestroy(data);

    return(newData);

}

/**

 * xmlSecKeyDataDestroy:

 * @data: 		the pointer to the key data.

 *

 * Destroys the data and frees all allocated memory. 

 */

EXPORT_C

void

xmlSecKeyDataDestroy(xmlSecKeyDataPtr data) {

    xmlSecAssert(xmlSecKeyDataIsValid(data));    

    xmlSecAssert(data->id->objSize > 0);

    if(data->id->finalize != NULL) { 

	(data->id->finalize)(data);

    }

    memset(data, 0, data->id->objSize);

    xmlFree(data);

}

/**

 * xmlSecKeyDataXmlRead:

 * @id: 		the data klass.

 * @key: 		the destination key.

 * @node: 		the pointer to an XML node.

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

 * 

 * Reads the key data of klass @id from XML @node and adds them to @key.

 *

 * Returns 0 on success or a negative value otherwise.

 */

EXPORT_C

int

xmlSecKeyDataXmlRead(xmlSecKeyDataId id, xmlSecKeyPtr key, xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx) {

    xmlSecAssert2(id != NULL, -1);

    xmlSecAssert2(id->xmlRead != NULL, -1);

    xmlSecAssert2(key != NULL, -1);

    xmlSecAssert2(node != NULL, -1);

    return((id->xmlRead)(id, key, node, keyInfoCtx));

}

/**

 * xmlSecKeyDataXmlWrite:

 * @id: 		the data klass.

 * @key: 		the source key.

 * @node: 		the pointer to an XML node.

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

 * 

 * Writes the key data of klass @id from @key to an XML @node.

 *

 * Returns 0 on success or a negative value otherwise.

 */

EXPORT_C

int

xmlSecKeyDataXmlWrite(xmlSecKeyDataId id, xmlSecKeyPtr key, xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx) {

    xmlSecAssert2(id != NULL, -1);

    xmlSecAssert2(id->xmlWrite != NULL, -1);

    xmlSecAssert2(key != NULL, -1);

    xmlSecAssert2(node != NULL, -1);

    return((id->xmlWrite)(id, key, node, keyInfoCtx));

}

/** 

 * xmlSecKeyDataBinRead:

 * @id: 		the data klass.

 * @key: 		the destination key.

 * @buf: 		the input binary buffer.

 * @bufSize: 		the input buffer size.

 * @keyInfoCtx: 	the <dsig:KeyInfo/> node processing context.

 *

 * Reads the key data of klass @id from binary buffer @buf to @key.

 * 

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

 */

EXPORT_C

int

xmlSecKeyDataBinRead(xmlSecKeyDataId id, xmlSecKeyPtr key, 

		    const xmlSecByte* buf, xmlSecSize bufSize, 

		    xmlSecKeyInfoCtxPtr keyInfoCtx) {

    xmlSecAssert2(id != NULL, -1);

    xmlSecAssert2(id->binRead != NULL, -1);

    xmlSecAssert2(key != NULL, -1);

    xmlSecAssert2(buf != NULL, -1);

    return((id->binRead)(id, key, buf, bufSize, keyInfoCtx));

}

/** 

 * xmlSecKeyDataBinWrite:

 * @id: 		the data klass.

 * @key: 		the source key.

 * @buf: 		the output binary buffer.

 * @bufSize: 		the output buffer size.

 * @keyInfoCtx: 	the <dsig:KeyInfo/> node processing context.

 *

 * Writes the key data of klass @id from the @key to a binary buffer @buf. 

 * 

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

 */

EXPORT_C

int

xmlSecKeyDataBinWrite(xmlSecKeyDataId id, xmlSecKeyPtr key, 

		    xmlSecByte** buf, xmlSecSize* bufSize, 

		    xmlSecKeyInfoCtxPtr keyInfoCtx) {

    xmlSecAssert2(id != NULL, -1);

    xmlSecAssert2(id->binWrite != NULL, -1);

    xmlSecAssert2(key != NULL, -1);

    xmlSecAssert2(buf != NULL, -1);

    return((id->binWrite)(id, key, buf, bufSize, keyInfoCtx));

}

/** 

 * xmlSecKeyDataGenerate:

 * @data: 		the pointer to key data.

 * @sizeBits: 		the desired key data size (in bits).

 * @type:		the desired key data type.

 *

 * Generates new key data of given size and type.

 *

 * Returns 0 on success or a negative value otherwise.

 */

EXPORT_C

int

xmlSecKeyDataGenerate(xmlSecKeyDataPtr data, xmlSecSize sizeBits, 

		      xmlSecKeyDataType type) {

    int ret;

    xmlSecAssert2(xmlSecKeyDataIsValid(data), -1);

    xmlSecAssert2(data->id->generate != NULL, -1);

    /* write data */

    ret = data->id->generate(data, sizeBits, type);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

		    "id->generate",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "size=%d", sizeBits);

	return(-1);	    

    }

    return(0);    

}

/** 

 * xmlSecKeyDataGetType:

 * @data: 		the pointer to key data.

 *

 * Gets key data type.

 *

 * Returns key data type.

 */

EXPORT_C  

xmlSecKeyDataType	

xmlSecKeyDataGetType(xmlSecKeyDataPtr data) {

    xmlSecAssert2(xmlSecKeyDataIsValid(data), xmlSecKeyDataTypeUnknown);

    xmlSecAssert2(data->id->getType != NULL, xmlSecKeyDataTypeUnknown);

    return(data->id->getType(data));

}

/** 

 * xmlSecKeyDataGetSize:

 * @data: 		the pointer to key data.

 *

 * Gets key data size.

 *

 * Returns key data size (in bits).

 */

EXPORT_C

xmlSecSize

xmlSecKeyDataGetSize(xmlSecKeyDataPtr data) {

    xmlSecAssert2(xmlSecKeyDataIsValid(data), 0);

    xmlSecAssert2(data->id->getSize != NULL, 0);

    return(data->id->getSize(data));

}

/**

 * xmlSecKeyDataGetIdentifier:

 * @data: 		the pointer to key data.

 * 

 * Gets key data identifier string.

 *

 * Returns key data id string.

 */

EXPORT_C

const xmlChar*

xmlSecKeyDataGetIdentifier(xmlSecKeyDataPtr data) {

    xmlSecAssert2(xmlSecKeyDataIsValid(data), NULL);

    xmlSecAssert2(data->id->getIdentifier != NULL, NULL);

    return(data->id->getIdentifier(data));

}

/** 

 * xmlSecKeyDataDebugDump:

 * @data: 		the pointer to key data.

 * @output: 		the pointer to output FILE.

 *

 * Prints key data debug info.

 */

EXPORT_C

void

xmlSecKeyDataDebugDump(xmlSecKeyDataPtr data, FILE *output) {

    xmlSecAssert(xmlSecKeyDataIsValid(data));

    xmlSecAssert(data->id->debugDump != NULL);

    xmlSecAssert(output != NULL);

    data->id->debugDump(data, output);

}

/** 

 * xmlSecKeyDataDebugXmlDump:

 * @data: 		the pointer to key data.

 * @output: 		the pointer to output FILE.

 *

 * Prints key data debug info in XML format.

 */

EXPORT_C 

void 

xmlSecKeyDataDebugXmlDump(xmlSecKeyDataPtr data, FILE *output) {

    xmlSecAssert(xmlSecKeyDataIsValid(data));

    xmlSecAssert(data->id->debugXmlDump != NULL);

    xmlSecAssert(output != NULL);

    data->id->debugXmlDump(data, output);

}

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

 *

 * xmlSecKeyDataBinary methods

 *

 * key (xmlSecBuffer) is located after xmlSecKeyData structure

 *

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

/** 

 * xmlSecKeyDataBinaryValueInitialize:

 * @data: 		the pointer to binary key data.

 *

 * Initializes key data.

 * 

 * Returns 0 on success or a negative value otherwise.

 */

EXPORT_C

int