/** 

 * XMLSec library

 *

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

#include <string.h>

#include "xmlsecc_config.h"

#include "xmlsec_xmlsec.h"

#include "xmlsec_xmltree.h"

#include "xmlsec_keys.h"

#include "xmlsec_keyinfo.h"

#include "xmlsec_transforms.h"

#include "xmlsec_errors.h"

#include "xmlsec_error_flag.h"

#include "xmlsecc_crypto.h"

#include "xmlsecc_cryptowrapper.h"

#include "xmlsecc_evp.h"

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

 *

 * Internal SymbianCrypto EVP key CTX

 *

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

typedef struct _xmlSecSymbianCryptoEvpKeyDataCtx	xmlSecSymbianCryptoEvpKeyDataCtx, 

						*xmlSecSymbianCryptoEvpKeyDataCtxPtr;

struct _xmlSecSymbianCryptoEvpKeyDataCtx {

    EVP_PKEY*		pKey;

};

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

 *

 * EVP key (dsa/rsa)

 *

 * xmlSecSymbianCryptoEvpKeyDataCtx is located after xmlSecTransform

 *

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

#define xmlSecSymbianCryptoEvpKeyDataSize	\

    (sizeof(xmlSecKeyData) + sizeof(xmlSecSymbianCryptoEvpKeyDataCtx))	

#define xmlSecSymbianCryptoEvpKeyDataGetCtx(data) \

    ((xmlSecSymbianCryptoEvpKeyDataCtxPtr)(((xmlSecByte*)(data)) + sizeof(xmlSecKeyData)))

static int		xmlSecSymbianCryptoEvpKeyDataInitialize	(xmlSecKeyDataPtr data);

static int		xmlSecSymbianCryptoEvpKeyDataDuplicate	(xmlSecKeyDataPtr dst,

								 xmlSecKeyDataPtr src);

static void		xmlSecSymbianCryptoEvpKeyDataFinalize		(xmlSecKeyDataPtr data);

/**

 * xmlSecSymbianCryptoEvpKeyDataAdoptEvp:

 * @data:		the pointer to SymbianCrypto EVP key data.

 * @pKey:		the pointer to EVP key.

 *

 * Sets the value of key data.

 *

 * Returns 0 on success or a negative value otherwise.

 */

EXPORT_C

int 

xmlSecSymbianCryptoEvpKeyDataAdoptEvp(xmlSecKeyDataPtr data, EVP_PKEY* pKey) {

    xmlSecSymbianCryptoEvpKeyDataCtxPtr ctx;

    xmlSecAssert2(xmlSecKeyDataIsValid(data), -1);

    xmlSecAssert2(xmlSecKeyDataCheckSize(data, xmlSecSymbianCryptoEvpKeyDataSize), -1);

    xmlSecAssert2(pKey, -1);

    ctx = xmlSecSymbianCryptoEvpKeyDataGetCtx(data);

    xmlSecAssert2(ctx, -1);

    if(ctx->pKey) {

	sc_pkey_free(ctx->pKey);

    }

    ctx->pKey = pKey;

    return(0);

}

/**

 * xmlSecSymbianCryptoEvpKeyDataGetEvp:

 * @data:		the pointer to SymbianCrypto EVP data.

 *

 * Gets the EVP_PKEY from the key data.

 *

 * Returns pointer to EVP_PKEY or NULL if an error occurs.

 */

EXPORT_C

EVP_PKEY* 

xmlSecSymbianCryptoEvpKeyDataGetEvp(xmlSecKeyDataPtr data) {

    xmlSecSymbianCryptoEvpKeyDataCtxPtr ctx;

    xmlSecAssert2(xmlSecKeyDataIsValid(data), NULL);

    xmlSecAssert2(xmlSecKeyDataCheckSize(data, xmlSecSymbianCryptoEvpKeyDataSize), NULL);

    ctx = xmlSecSymbianCryptoEvpKeyDataGetCtx(data);

    xmlSecAssert2(ctx, NULL);

    return(ctx->pKey);

	//return NULL;    

}

static int

xmlSecSymbianCryptoEvpKeyDataInitialize(xmlSecKeyDataPtr data) {

    xmlSecSymbianCryptoEvpKeyDataCtxPtr ctx;

    xmlSecAssert2(xmlSecKeyDataIsValid(data), -1);

    xmlSecAssert2(xmlSecKeyDataCheckSize(data, xmlSecSymbianCryptoEvpKeyDataSize), -1);

    ctx = xmlSecSymbianCryptoEvpKeyDataGetCtx(data);

    xmlSecAssert2(ctx, -1);

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

    return(0);

}

static int

xmlSecSymbianCryptoEvpKeyDataDuplicate(xmlSecKeyDataPtr dst, xmlSecKeyDataPtr src) {

    xmlSecSymbianCryptoEvpKeyDataCtxPtr ctxDst;

    xmlSecSymbianCryptoEvpKeyDataCtxPtr ctxSrc;

    xmlSecAssert2(xmlSecKeyDataIsValid(dst), -1);

    xmlSecAssert2(xmlSecKeyDataCheckSize(dst, xmlSecSymbianCryptoEvpKeyDataSize), -1);

    xmlSecAssert2(xmlSecKeyDataIsValid(src), -1);

    xmlSecAssert2(xmlSecKeyDataCheckSize(src, xmlSecSymbianCryptoEvpKeyDataSize), -1);

    ctxDst = xmlSecSymbianCryptoEvpKeyDataGetCtx(dst);

    xmlSecAssert2(ctxDst, -1);

    xmlSecAssert2(!ctxDst->pKey, -1);

    ctxSrc = xmlSecSymbianCryptoEvpKeyDataGetCtx(src);

    xmlSecAssert2(ctxSrc, -1);

	ctxDst->pKey = xmlSecSymbianCryptoEvpKeyDup(ctxSrc->pKey);

    return(0);

}

static void

xmlSecSymbianCryptoEvpKeyDataFinalize(xmlSecKeyDataPtr data) {

    xmlSecSymbianCryptoEvpKeyDataCtxPtr ctx;

    xmlSecAssert(xmlSecKeyDataIsValid(data));

    xmlSecAssert(xmlSecKeyDataCheckSize(data, xmlSecSymbianCryptoEvpKeyDataSize));

    ctx = xmlSecSymbianCryptoEvpKeyDataGetCtx(data);

    xmlSecAssert(ctx);

    if(ctx->pKey) {

	sc_pkey_free(ctx->pKey);

    }

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

}

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

 *

 * Symbian Keys Store

 *

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

#define xmlSecSymbianKeysStoreSize \

	(sizeof(xmlSecKeyStore)+ sizeof(xmlSecPtrList))

#define xmlSecSymbianKeysStoreGetList(store) \

    ((xmlSecKeyStoreCheckSize((store), xmlSecSymbianKeysStoreSize)) ? \

	(xmlSecPtrListPtr)(((xmlSecByte*)(store)) + sizeof(xmlSecKeyStore)) : \

	(xmlSecPtrListPtr)NULL)

static xmlSecKeyPtr 		xmlSecSymbianKeysStoreFindKey	(xmlSecKeyStorePtr store, 

								 const xmlChar* name, 

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static xmlSecKeyStoreKlass xmlSecSymbianKeysStoreKlass = {

    sizeof(xmlSecKeyStoreKlass),

    xmlSecSymbianKeysStoreSize,

    /* data */

    BAD_CAST "symbian-keys-store",		/* const xmlChar* name; */ 

    /* constructors/destructor */

    NULL,		/* xmlSecKeyStoreInitializeMethod initialize; */

    NULL,		/* xmlSecKeyStoreFinalizeMethod finalize; */

    xmlSecSymbianKeysStoreFindKey,		/* xmlSecKeyStoreFindKeyMethod findKey; */

    /* reserved for the future */

    NULL,					/* void* reserved0; */

    NULL, 					/* void* reserved1; */

};

/**

 * xmlSecSymbianKeysStoreGetKlass:

 * 

 * The Symbian list based keys store klass.

 *

 * Returns simple list based keys store klass.

 */

EXPORT_C

xmlSecKeyStoreId 

xmlSecSymbianKeysStoreGetKlass(void) {

    return(&xmlSecSymbianKeysStoreKlass);

}

static xmlSecKeyPtr 

xmlSecSymbianKeysStoreFindKey(xmlSecKeyStorePtr store, const xmlChar* name, 

			    xmlSecKeyInfoCtxPtr keyInfoCtx) {

    xmlSecKeyPtr key=NULL;

    xmlSecAssert2(xmlSecKeyStoreCheckId(store, xmlSecSymbianKeysStoreId), NULL);

    xmlSecAssert2(keyInfoCtx, NULL);

    if((!name) || (keyInfoCtx->keyReq.keyId == xmlSecKeyDataIdUnknown)){

	return(NULL);

    }

    if(keyInfoCtx->keyReq.keyId== xmlSecSymbianCryptoKeyDataRsaId) {

    key=xmlSecSymbianCryptoAppKeyLoadSks((char*)name);	

    if(!key) {

            xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecSymbianKeysStoreFindKey",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "name=%s", 

		    xmlSecErrorsSafeString(name));

	    return(NULL);

        }

    }

    return(key);

}

/**

 * xmlSecSymbianCryptoAppKeyLoadSks:

 * @keyname:		the key name.

 *

 * Reads key from the symbian keystore.

 *

 * Returns pointer to the key or NULL if an error occurs.

 */

EXPORT_C

xmlSecKeyPtr

xmlSecSymbianCryptoAppKeyLoadSks(char* keyname) {

    xmlSecKeyPtr key = NULL;

    xmlSecKeyDataPtr data;

    EVP_PKEY* pKey = NULL;    

    int ret;

    xmlSecAssert2(keyname, NULL);

    pKey = d2i_PKCS8PrivateKey(keyname);

    if(!pKey) {

		    xmlSecError(XMLSEC_ERRORS_HERE,

				NULL,

				"sc_PrivateKey_read",

				XMLSEC_ERRORS_R_CRYPTO_FAILED,

				XMLSEC_ERRORS_NO_MESSAGE);

		    return(NULL);

		}    					    		  

    data = xmlSecSymbianCryptoEvpKeyAdopt(pKey);

    if(!data) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecSymbianCryptoEvpKeyAdopt",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	sc_pkey_free(pKey);

	return(NULL);	    

    }   

    key = xmlSecKeyCreate();

    if(!key) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeyCreate",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	xmlSecKeyDataDestroy(data);

	return(NULL);

    }

    ret = xmlSecKeySetValue(key, data);

    if(ret < 0) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecKeySetValue",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    "data=%s",

		    xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)));

	xmlSecKeyDestroy(key);

	xmlSecKeyDataDestroy(data);

	return(NULL);

    } 

    return(key);

}

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

 *

 * EVP helper functions

 *

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

/**

 * xmlSecSymbianCryptoEvpKeyDup:

 * @pKey:		the pointer to EVP_PKEY.

 *

 * Duplicates @pKey.

 *

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

 */

EXPORT_C

EVP_PKEY* 

xmlSecSymbianCryptoEvpKeyDup(EVP_PKEY* pKey) {

    EVP_PKEY* pKeyNew;

    xmlSecAssert2(pKey, NULL);

    pKeyNew = sc_pkey_duplicate(pKey);

    if(!pKeyNew) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "sc_pkey_duplicate",

		    XMLSEC_ERRORS_R_CRYPTO_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(NULL);		    	

    }

    return (pKeyNew);

}

/**

 * xmlSecSymbianCryptoEvpKeyAdopt:

 * @pKey:		the pointer to EVP_PKEY.

 *

 * Creates xmlsec key object from SymbianCrypto key object.

 *

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

 */

EXPORT_C

xmlSecKeyDataPtr

xmlSecSymbianCryptoEvpKeyAdopt(EVP_PKEY *pKey) {

    xmlSecKeyDataPtr data = NULL;

    int ret;

    xmlSecAssert2(pKey, NULL);

    switch(pKey->type) {	

#ifndef XMLSEC_NO_RSA    

    case EVP_PKEY_RSA:

	data = xmlSecKeyDataCreate(xmlSecSymbianCryptoKeyDataRsaId);

	if(!data) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

			NULL,

			"xmlSecKeyDataCreate",

			XMLSEC_ERRORS_R_XMLSEC_FAILED,

			"xmlSecSymbianCryptoKeyDataRsaId");

	    return(NULL);	    

	}

	break;

#endif /* XMLSEC_NO_RSA */	

#ifndef XMLSEC_NO_DSA	

    case EVP_PKEY_DSA:

	data = xmlSecKeyDataCreate(xmlSecSymbianCryptoKeyDataDsaId);

	if(!data) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

			NULL,

			"xmlSecKeyDataCreate",

			XMLSEC_ERRORS_R_XMLSEC_FAILED,

			"xmlSecSymbianCryptoKeyDataDsaId");

	    return(NULL);	    

	}

	break;

#endif /* XMLSEC_NO_DSA */	

    default:	

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    NULL,

		    XMLSEC_ERRORS_R_INVALID_TYPE,

		    "evp key type %d not supported", pKey->type);

	return(NULL);

    }

    xmlSecAssert2(data, NULL);    

    ret = xmlSecSymbianCryptoEvpKeyDataAdoptEvp(data, pKey);

    if(ret < 0) {	

	xmlSecError(XMLSEC_ERRORS_HERE,

		    NULL,

		    "xmlSecSymbianCryptoEvpKeyDataAdoptEvp",

		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	xmlSecKeyDataDestroy(data);

	return(NULL);	    

    }

    return(data);

}

#ifndef XMLSEC_NO_DSA    

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

 *

 * <dsig:DSAKeyValue> processing

 *

 *

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

 *

 * DSA keys and the DSA signature algorithm are specified in [DSS]. 

 * DSA public key values can have the following fields:

 *      

 *   * P - a prime modulus meeting the [DSS] requirements 

 *   * Q - an integer in the range 2**159 < Q < 2**160 which is a prime 

 *         divisor of P-1 

 *   * G - an integer with certain properties with respect to P and Q 

 *   * Y - G**X mod P (where X is part of the private key and not made 

 *	   public) 

 *   * J - (P - 1) / Q 

 *   * seed - a DSA prime generation seed 

 *   * pgenCounter - a DSA prime generation counter

 *

 * Parameter J is available for inclusion solely for efficiency as it is 

 * calculatable from P and Q. Parameters seed and pgenCounter are used in the 

 * DSA prime number generation algorithm specified in [DSS]. As such, they are 

 * optional but must either both be present or both be absent. This prime 

 * generation algorithm is designed to provide assurance that a weak prime is 

 * not being used and it yields a P and Q value. Parameters P, Q, and G can be 

 * public and common to a group of users. They might be known from application 

 * context. As such, they are optional but P and Q must either both appear or 

 * both be absent. If all of P, Q, seed, and pgenCounter are present, 

 * implementations are not required to check if they are consistent and are 

 * free to use either P and Q or seed and pgenCounter. All parameters are 

 * encoded as base64 [MIME] values.

 *     

 * Arbitrary-length integers (e.g. "bignums" such as RSA moduli) are 

 * represented in XML as octet strings as defined by the ds:CryptoBinary type.

 *     

 * Schema Definition:

 *     

 * <element name="DSAKeyValue" type="ds:DSAKeyValueType"/> 

 * <complexType name="DSAKeyValueType"> 

 *   <sequence>

 *     <sequence minOccurs="0">

 *        <element name="P" type="ds:CryptoBinary"/> 

 *        <element name="Q" type="ds:CryptoBinary"/>

 *     </sequence>

 *     <element name="G" type="ds:CryptoBinary" minOccurs="0"/> 

 *     <element name="Y" type="ds:CryptoBinary"/> 

 *     <element name="J" type="ds:CryptoBinary" minOccurs="0"/>

 *     <sequence minOccurs="0">

 *       <element name="Seed" type="ds:CryptoBinary"/> 

 *       <element name="PgenCounter" type="ds:CryptoBinary"/> 

 *     </sequence>

 *   </sequence>

 * </complexType>

 *     

 * DTD Definition:

 *     

 *  <!ELEMENT DSAKeyValue ((P, Q)?, G?, Y, J?, (Seed, PgenCounter)?) > 

 *  <!ELEMENT P (#PCDATA) >

 *  <!ELEMENT Q (#PCDATA) >

 *  <!ELEMENT G (#PCDATA) >

 *  <!ELEMENT Y (#PCDATA) >

 *  <!ELEMENT J (#PCDATA) >

 *  <!ELEMENT Seed (#PCDATA) >

 *  <!ELEMENT PgenCounter (#PCDATA) >

 *

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

 * 

 * To support reading/writing private keys an X element added (before Y).

 * Note: The current implementation does not support Seed and PgenCounter!

 * by this the P, Q and G are *required*!

 *

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

static int		xmlSecSymbianCryptoKeyDataDsaInitialize	(xmlSecKeyDataPtr data);

static int		xmlSecSymbianCryptoKeyDataDsaDuplicate	(xmlSecKeyDataPtr dst,

								 xmlSecKeyDataPtr src);

static void		xmlSecSymbianCryptoKeyDataDsaFinalize		(xmlSecKeyDataPtr data);

static int		xmlSecSymbianCryptoKeyDataDsaXmlRead		(xmlSecKeyDataId id,

								 xmlSecKeyPtr key,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoKeyDataDsaXmlWrite		(xmlSecKeyDataId id,

								 xmlSecKeyPtr key,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoKeyDataDsaGenerate		(xmlSecKeyDataPtr data,

								 xmlSecSize sizeBits,

								 xmlSecKeyDataType type);

static xmlSecKeyDataType xmlSecSymbianCryptoKeyDataDsaGetType		(xmlSecKeyDataPtr data);

static xmlSecSize		xmlSecSymbianCryptoKeyDataDsaGetSize		(xmlSecKeyDataPtr data);

static void		xmlSecSymbianCryptoKeyDataDsaDebugDump	(xmlSecKeyDataPtr data,

								 FILE* output);

static void		xmlSecSymbianCryptoKeyDataDsaDebugXmlDump	(xmlSecKeyDataPtr data,

								 FILE* output);

static xmlSecKeyDataKlass xmlSecSymbianCryptoKeyDataDsaKlass = {

    sizeof(xmlSecKeyDataKlass),

    xmlSecSymbianCryptoEvpKeyDataSize,

    /* data */

    xmlSecNameDSAKeyValue,

    xmlSecKeyDataUsageKeyValueNode | xmlSecKeyDataUsageRetrievalMethodNodeXml, 

						/* xmlSecKeyDataUsage usage; */

    xmlSecHrefDSAKeyValue,			/* const xmlChar* href; */

    xmlSecNodeDSAKeyValue,			/* const xmlChar* dataNodeName; */

    xmlSecDSigNs,				/* const xmlChar* dataNodeNs; */

    /* constructors/destructor */

    xmlSecSymbianCryptoKeyDataDsaInitialize,		/* xmlSecKeyDataInitializeMethod initialize; */