/** 

 * XMLSec library

 *

 * X509 support

 *

 *

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

#include "xmlsecc_config.h"

#ifndef XMLSEC_NO_X509

#include "xmlsecc_globals.h"

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <ctype.h>

#include <errno.h>

#include <time.h>

#include "xmlsec_xmlsec.h"

#include "xmlsec_xmltree.h"

#include "xmlsec_keys.h"

#include "xmlsec_keyinfo.h"

#include "xmlsec_keysmngr.h"

#include "xmlsec_x509.h"

#include "xmlsec_base64.h"

#include "xmlsec_errors.h"

#include "xmlsecc_crypto.h"

#include "xmlsecc_evp.h"

#include "xmlsecc_x509.h"

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

 *

 * X509 utility functions

 *

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

static int		xmlSecSymbianCryptoX509DataNodeRead		(xmlSecKeyDataPtr data,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoX509CertificateNodeRead	(xmlSecKeyDataPtr data,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoX509CertificateNodeWrite	(X509* cert,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoX509SubjectNameNodeRead	(xmlSecKeyDataPtr data,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoX509SubjectNameNodeWrite	(X509* cert,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoX509IssuerSerialNodeRead	(xmlSecKeyDataPtr data,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoX509IssuerSerialNodeWrite	(X509* cert,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoX509SKINodeRead		(xmlSecKeyDataPtr data,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoX509SKINodeWrite		(X509* cert,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoX509CRLNodeRead		(xmlSecKeyDataPtr data,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoX509CRLNodeWrite		(X509_CRL* crl,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoKeyDataX509VerifyAndExtractKey(xmlSecKeyDataPtr data, 

								xmlSecKeyPtr key,

								xmlSecKeyInfoCtxPtr keyInfoCtx);

static X509*		xmlSecSymbianCryptoX509CertDerRead		(const xmlSecByte* buf, 

								 xmlSecSize size);

static X509*		xmlSecSymbianCryptoX509CertBase64DerRead	(xmlChar* buf);

static xmlChar*		xmlSecSymbianCryptoX509CertBase64DerWrite	(X509* cert, 

								 int base64LineWrap);

static X509_CRL*	xmlSecSymbianCryptoX509CrlDerRead		(xmlSecByte* buf, 

								 xmlSecSize size);

static X509_CRL*	xmlSecSymbianCryptoX509CrlBase64DerRead	(xmlChar* buf);

static xmlChar*		xmlSecSymbianCryptoX509CrlBase64DerWrite	(X509_CRL* crl, 

								 int base64LineWrap);

//static xmlChar*		xmlSecSymbianCryptoX509NameWrite		(X509_NAME* nm);

#ifdef XMLSEC_FUTURE_SUPPORT

static xmlChar*		xmlSecSymbianCryptoASN1IntegerWrite		(ASN1_INTEGER *asni);

#endif //XMLSEC_FUTURE_SUPPORT

static xmlChar*		xmlSecSymbianCryptoX509SKIWrite		(X509* cert);

static void		xmlSecSymbianCryptoX509CertDebugDump		(X509* cert, 

								 FILE* output);

static void		xmlSecSymbianCryptoX509CertDebugXmlDump	(X509* cert, 

								 FILE* output);

#ifdef XMLSEC_FUTURE_SUPPORT								 

static int		xmlSecSymbianCryptoX509CertGetTime		(ASN1_TIME* t,

								 time_t* res);

#endif //XMLSEC_FUTURE_SUPPORT

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

*

* Support for SymbianCertStore

*

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

static int XmlSecCertStoreFlag = 0;

// ---------------------------------------------------------------------------

// Set SymbianCertStore flag.

// ---------------------------------------------------------------------------

//

EXPORT_C 

void xmlSecSetCertStoreFlag()

    {

    XmlSecCertStoreFlag = 1;

    }

// ---------------------------------------------------------------------------

// Reset SymbianCertStore  flag.

// ---------------------------------------------------------------------------

//

EXPORT_C 

void xmlSecResetCertStoreFlag()

    {

    XmlSecCertStoreFlag = 0;

    }

// ---------------------------------------------------------------------------

// Check SymbianCertStore  flag.

// ---------------------------------------------------------------------------

//

EXPORT_C 

int xmlSecCheckCertStoreFlag()

    {

    return XmlSecCertStoreFlag;

    }    

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

 *

 * Internal SymbianCrypto X509 data CTX

 *

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

typedef struct _xmlSecSymbianCryptoX509DataCtx		xmlSecSymbianCryptoX509DataCtx,

							*xmlSecSymbianCryptoX509DataCtxPtr;

struct _xmlSecSymbianCryptoX509DataCtx {

    X509*		keyCert;

    STACK_OF(X509)*	certsList;

    STACK_OF(X509_CRL)*	crlsList;

};

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

 *

 * <dsig:X509Data> processing

 *

 *

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

 *

 * An X509Data element within KeyInfo contains one or more identifiers of keys 

 * or X509 certificates (or certificates' identifiers or a revocation list). 

 * The content of X509Data is:

 *

 *  1. At least one element, from the following set of element types; any of these may appear together or more than once iff (if and only if) each instance describes or is related to the same certificate:

 *  2.

 *    * The X509IssuerSerial element, which contains an X.509 issuer 

 *	distinguished name/serial number pair that SHOULD be compliant 

 *	with RFC2253 [LDAP-DN],

 *    * The X509SubjectName element, which contains an X.509 subject 

 *	distinguished name that SHOULD be compliant with RFC2253 [LDAP-DN],

 *    * The X509SKI element, which contains the base64 encoded plain (i.e. 

 *	non-DER-encoded) value of a X509 V.3 SubjectKeyIdentifier extension.

 *    * The X509Certificate element, which contains a base64-encoded [X509v3] 

 *	certificate, and

 *    * Elements from an external namespace which accompanies/complements any 

 *	of the elements above.

 *    * The X509CRL element, which contains a base64-encoded certificate 

 *	revocation list (CRL) [X509v3].

 *

 * Any X509IssuerSerial, X509SKI, and X509SubjectName elements that appear 

 * MUST refer to the certificate or certificates containing the validation key.

 * All such elements that refer to a particular individual certificate MUST be 

 * grouped inside a single X509Data element and if the certificate to which 

 * they refer appears, it MUST also be in that X509Data element.

 *

 * Any X509IssuerSerial, X509SKI, and X509SubjectName elements that relate to 

 * the same key but different certificates MUST be grouped within a single 

 * KeyInfo but MAY occur in multiple X509Data elements.

 *

 * All certificates appearing in an X509Data element MUST relate to the 

 * validation key by either containing it or being part of a certification 

 * chain that terminates in a certificate containing the validation key.

 *

 * No ordering is implied by the above constraints.

 *

 * Note, there is no direct provision for a PKCS#7 encoded "bag" of 

 * certificates or CRLs. However, a set of certificates and CRLs can occur 

 * within an X509Data element and multiple X509Data elements can occur in a 

 * KeyInfo. Whenever multiple certificates occur in an X509Data element, at 

 * least one such certificate must contain the public key which verifies the 

 * signature.

 *

 * Schema Definition

 *

 *  <element name="X509Data" type="ds:X509DataType"/> 

 *  <complexType name="X509DataType">

 *    <sequence maxOccurs="unbounded">

 *      <choice>

 *        <element name="X509IssuerSerial" type="ds:X509IssuerSerialType"/>

 *        <element name="X509SKI" type="base64Binary"/>

 *        <element name="X509SubjectName" type="string"/>

 *        <element name="X509Certificate" type="base64Binary"/>

 *        <element name="X509CRL" type="base64Binary"/>

 *        <any namespace="##other" processContents="lax"/>

 *      </choice>

 *    </sequence>

 *  </complexType>

 *  <complexType name="X509IssuerSerialType"> 

 *    <sequence> 

 *       <element name="X509IssuerName" type="string"/> 

 *       <element name="X509SerialNumber" type="integer"/> 

 *     </sequence>

 *  </complexType>

 *

 *  DTD

 *

 *    <!ELEMENT X509Data ((X509IssuerSerial | X509SKI | X509SubjectName |

 *                          X509Certificate | X509CRL)+ %X509.ANY;)>

 *    <!ELEMENT X509IssuerSerial (X509IssuerName, X509SerialNumber) >

 *    <!ELEMENT X509IssuerName (#PCDATA) >

 *    <!ELEMENT X509SubjectName (#PCDATA) >

 *    <!ELEMENT X509SerialNumber (#PCDATA) >

 *    <!ELEMENT X509SKI (#PCDATA) >

 *    <!ELEMENT X509Certificate (#PCDATA) >

 *    <!ELEMENT X509CRL (#PCDATA) >

 *

 * -----------------------------------------------------------------------

 *

 * xmlSecSymbianCryptoX509DataCtx is located after xmlSecTransform

 *

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

#define xmlSecSymbianCryptoX509DataSize	\

    (sizeof(xmlSecKeyData) + sizeof(xmlSecSymbianCryptoX509DataCtx))	

#define xmlSecSymbianCryptoX509DataGetCtx(data) \

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

static int		xmlSecSymbianCryptoKeyDataX509Initialize	(xmlSecKeyDataPtr data);

static int		xmlSecSymbianCryptoKeyDataX509Duplicate	(xmlSecKeyDataPtr dst,

								 xmlSecKeyDataPtr src);

static void		xmlSecSymbianCryptoKeyDataX509Finalize	(xmlSecKeyDataPtr data);

static int		xmlSecSymbianCryptoKeyDataX509XmlRead		(xmlSecKeyDataId id,

								 xmlSecKeyPtr key,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static int		xmlSecSymbianCryptoKeyDataX509XmlWrite	(xmlSecKeyDataId id,

								 xmlSecKeyPtr key,

								 xmlNodePtr node,

								 xmlSecKeyInfoCtxPtr keyInfoCtx);

static xmlSecKeyDataType xmlSecSymbianCryptoKeyDataX509GetType	(xmlSecKeyDataPtr data);

static const xmlChar*	xmlSecSymbianCryptoKeyDataX509GetIdentifier	(xmlSecKeyDataPtr data);

static void		xmlSecSymbianCryptoKeyDataX509DebugDump	(xmlSecKeyDataPtr data,

								 FILE* output);

static void		xmlSecSymbianCryptoKeyDataX509DebugXmlDump	(xmlSecKeyDataPtr data,

								 FILE* output);

static xmlSecKeyDataKlass xmlSecSymbianCryptoKeyDataX509Klass = {

    sizeof(xmlSecKeyDataKlass),

    xmlSecSymbianCryptoX509DataSize,

    /* data */

    xmlSecNameX509Data,

    xmlSecKeyDataUsageKeyInfoNode | xmlSecKeyDataUsageRetrievalMethodNodeXml, 

						/* xmlSecKeyDataUsage usage; */

    xmlSecHrefX509Data,				/* const xmlChar* href; */

    xmlSecNodeX509Data,				/* const xmlChar* dataNodeName; */

    xmlSecDSigNs,				/* const xmlChar* dataNodeNs; */

    /* constructors/destructor */

    xmlSecSymbianCryptoKeyDataX509Initialize,		/* xmlSecKeyDataInitializeMethod initialize; */

    xmlSecSymbianCryptoKeyDataX509Duplicate,		/* xmlSecKeyDataDuplicateMethod duplicate; */

    xmlSecSymbianCryptoKeyDataX509Finalize,		/* xmlSecKeyDataFinalizeMethod finalize; */

    NULL,					/* xmlSecKeyDataGenerateMethod generate; */

    /* get info */

    xmlSecSymbianCryptoKeyDataX509GetType, 		/* xmlSecKeyDataGetTypeMethod getType; */

    NULL,					/* xmlSecKeyDataGetSizeMethod getSize; */

    xmlSecSymbianCryptoKeyDataX509GetIdentifier,	/* xmlSecKeyDataGetIdentifier getIdentifier; */    

    /* read/write */

    xmlSecSymbianCryptoKeyDataX509XmlRead,		/* xmlSecKeyDataXmlReadMethod xmlRead; */

    xmlSecSymbianCryptoKeyDataX509XmlWrite,		/* xmlSecKeyDataXmlWriteMethod xmlWrite; */

    NULL,					/* xmlSecKeyDataBinReadMethod binRead; */

    NULL,					/* xmlSecKeyDataBinWriteMethod binWrite; */

    /* debug */

    xmlSecSymbianCryptoKeyDataX509DebugDump,		/* xmlSecKeyDataDebugDumpMethod debugDump; */

    xmlSecSymbianCryptoKeyDataX509DebugXmlDump, 	/* xmlSecKeyDataDebugDumpMethod debugXmlDump; */

    /* reserved for the future */

    NULL,					/* void* reserved0; */

    NULL,					/* void* reserved1; */

};

/** 

 * xmlSecSymbianCryptoKeyDataX509GetKlass:

 * 

 * The SymbianCrypto X509 key data klass (http://www.w3.org/TR/xmldsig-core/#sec-X509Data).

 *

 * Returns the X509 data klass.

 */

EXPORT_C

xmlSecKeyDataId 

xmlSecSymbianCryptoKeyDataX509GetKlass(void) {

    return(&xmlSecSymbianCryptoKeyDataX509Klass);

}

/**

 * xmlSecSymbianCryptoKeyDataX509GetKeyCert:

 * @data:		the pointer to X509 key data.

 *

 * Gets the certificate from which the key was extracted. 

 *

 * Returns the key's certificate or NULL if key data was not used for key

 * extraction or an error occurs.

 */

EXPORT_C

X509* 	

xmlSecSymbianCryptoKeyDataX509GetKeyCert(xmlSecKeyDataPtr data) {

    xmlSecSymbianCryptoX509DataCtxPtr ctx;

    xmlSecAssert2(xmlSecKeyDataCheckId(data, xmlSecSymbianCryptoKeyDataX509Id), NULL);

    ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

    xmlSecAssert2(ctx, NULL);

    return(ctx->keyCert);

}

/**

 * xmlSecSymbianCryptoKeyDataX509AdoptKeyCert:

 * @data:		the pointer to X509 key data.

 * @cert:		the pointer to SymbianCrypto X509 certificate.

 *

 * Sets the key's certificate in @data.

 *

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

 */

EXPORT_C

int

xmlSecSymbianCryptoKeyDataX509AdoptKeyCert(xmlSecKeyDataPtr data, X509* cert) {

    xmlSecSymbianCryptoX509DataCtxPtr ctx;

    xmlSecAssert2(xmlSecKeyDataCheckId(data, xmlSecSymbianCryptoKeyDataX509Id), -1);

    xmlSecAssert2(cert, -1);

    ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

    xmlSecAssert2(ctx, -1);

    if(ctx->keyCert) {

	X509_free(ctx->keyCert);

    }

    ctx->keyCert = cert;

    return(0);

}

/**

 * xmlSecSymbianCryptoKeyDataX509AdoptCert:

 * @data:		the pointer to X509 key data.

 * @cert:		the pointer to SymbianCrypto X509 certificate.

 *

 * Adds certificate to the X509 key data.

 *

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

 */

EXPORT_C

int 

xmlSecSymbianCryptoKeyDataX509AdoptCert(xmlSecKeyDataPtr data, X509* cert) {

    xmlSecSymbianCryptoX509DataCtxPtr ctx;

    xmlSecAssert2(xmlSecKeyDataCheckId(data, xmlSecSymbianCryptoKeyDataX509Id), -1);

    xmlSecAssert2(cert, -1);

    ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

    xmlSecAssert2(ctx, -1);

    /*

    if(ctx->certsList == NULL) {

	ctx->certsList = sk_X509_new_null();

	if(ctx->certsList == NULL) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

			xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

			"sk_X509_new_null",

			XMLSEC_ERRORS_R_CRYPTO_FAILED,

			XMLSEC_ERRORS_NO_MESSAGE);

	    return(-1);	

	}

    }

    ret = sk_X509_push(ctx->certsList, cert);

    if(ret < 1) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

		    "sk_X509_push",

		    XMLSEC_ERRORS_R_CRYPTO_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);	

    }

    */

    return(0);

}

/**

 * xmlSecSymbianCryptoKeyDataX509GetCert:

 * @data:		the pointer to X509 key data.

 * @pos:		the desired certificate position.

 * 

 * Gets a certificate from X509 key data.

 *

 * Returns the pointer to certificate or NULL if @pos is larger than the 

 * number of certificates in @data or an error occurs.

 */

EXPORT_C

X509* 

xmlSecSymbianCryptoKeyDataX509GetCert(xmlSecKeyDataPtr data, xmlSecSize pos) {

    xmlSecSymbianCryptoX509DataCtxPtr ctx;

    xmlSecAssert2(xmlSecKeyDataCheckId(data, xmlSecSymbianCryptoKeyDataX509Id), NULL);

    ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

    xmlSecAssert2(ctx, NULL);

    xmlSecAssert2(ctx->certsList, NULL);

    return NULL;

}

/**

 * xmlSecSymbianCryptoKeyDataX509GetCertsSize:

 * @data:		the pointer to X509 key data.

 *

 * Gets the number of certificates in @data.

 *

 * Returns te number of certificates in @data.

 */

EXPORT_C

xmlSecSize 	

xmlSecSymbianCryptoKeyDataX509GetCertsSize(xmlSecKeyDataPtr data) {

    xmlSecSymbianCryptoX509DataCtxPtr ctx;

    xmlSecAssert2(xmlSecKeyDataCheckId(data, xmlSecSymbianCryptoKeyDataX509Id), 0);

    ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

    xmlSecAssert2(ctx, 0);

   return 0;

}

/**

 * xmlSecSymbianCryptoKeyDataX509AdoptCrl:

 * @data:		the pointer to X509 key data.

 * @crl:		the pointer to SymbianCrypto X509 CRL.

 *

 * Adds CRL to the X509 key data.

 *

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

 */

EXPORT_C

int 

xmlSecSymbianCryptoKeyDataX509AdoptCrl(xmlSecKeyDataPtr data, X509_CRL* crl) {

    xmlSecSymbianCryptoX509DataCtxPtr ctx;

    xmlSecAssert2(xmlSecKeyDataCheckId(data, xmlSecSymbianCryptoKeyDataX509Id), -1);

    xmlSecAssert2(crl, -1);

    ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

    xmlSecAssert2(ctx, -1);

    /*

    if(ctx->crlsList == NULL) {

	ctx->crlsList = sk_X509_CRL_new_null();

	if(ctx->crlsList == NULL) {

	    xmlSecError(XMLSEC_ERRORS_HERE,

			xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

			"sk_X509_CRL_new_null",

			XMLSEC_ERRORS_R_CRYPTO_FAILED,

			XMLSEC_ERRORS_NO_MESSAGE);

	    return(-1);	

	}

    }

    ret = sk_X509_CRL_push(ctx->crlsList, crl);

    if(ret < 1) {

	xmlSecError(XMLSEC_ERRORS_HERE,

		    xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

		    "sk_X509_CRL_push",

		    XMLSEC_ERRORS_R_CRYPTO_FAILED,

		    XMLSEC_ERRORS_NO_MESSAGE);

	return(-1);	

    }

    */

    return(0);

}

/**

 * xmlSecSymbianCryptoKeyDataX509GetCrl:

 * @data:		the pointer to X509 key data.

 * @pos:		the desired CRL position.

 * 

 * Gets a CRL from X509 key data.

 *

 * Returns the pointer to CRL or NULL if @pos is larger than the 

 * number of CRLs in @data or an error occurs.

 */

EXPORT_C

X509_CRL* 

xmlSecSymbianCryptoKeyDataX509GetCrl(xmlSecKeyDataPtr data, xmlSecSize pos) {

    xmlSecSymbianCryptoX509DataCtxPtr ctx;

    xmlSecAssert2(xmlSecKeyDataCheckId(data, xmlSecSymbianCryptoKeyDataX509Id), NULL);

    ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

    xmlSecAssert2(ctx, NULL);

    xmlSecAssert2(ctx->crlsList, NULL);

   return NULL;