1 /** 

     2  * XMLSec library

     3  *

     4  * X509 support

     5  *

     6  *

     7  * This is free software; see Copyright file in the source

     8  * distribution for preciese wording.

     9  * 

    10  * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>

    11  * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

    12  */

    13 //#include "globals.h"

    14 #include "xmlsecc_config.h"

    15 #ifndef XMLSEC_NO_X509

    16 #include "xmlsecc_globals.h"

    17 

    18 #include <stdlib.h>

    19 #include <stdio.h>

    20 #include <string.h>

    21 #include <ctype.h>

    22 #include <errno.h>

    23 #include <time.h>

    24 

    25 #include <libxml2_tree.h>

    26 #include <libxml2_globals.h>

    27 

    28 #include "xmlsec_xmlsec.h"

    29 #include "xmlsec_xmltree.h"

    30 #include "xmlsec_keys.h"

    31 #include "xmlsec_keyinfo.h"

    32 #include "xmlsec_keysmngr.h"

    33 #include "xmlsec_x509.h"

    34 #include "xmlsec_base64.h"

    35 #include "xmlsec_errors.h"

    36 

    37 #include "xmlsecc_crypto.h"

    38 #include "xmlsecc_evp.h"

    39 #include "xmlsecc_x509.h"

    40 

    41 /*************************************************************************

    42  *

    43  * X509 utility functions

    44  *

    45  ************************************************************************/

    46 static int		xmlSecSymbianCryptoX509DataNodeRead		(xmlSecKeyDataPtr data,

    47 								 xmlNodePtr node,

    48 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

    49 static int		xmlSecSymbianCryptoX509CertificateNodeRead	(xmlSecKeyDataPtr data,

    50 								 xmlNodePtr node,

    51 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

    52 static int		xmlSecSymbianCryptoX509CertificateNodeWrite	(X509* cert,

    53 								 xmlNodePtr node,

    54 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

    55 static int		xmlSecSymbianCryptoX509SubjectNameNodeRead	(xmlSecKeyDataPtr data,

    56 								 xmlNodePtr node,

    57 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

    58 static int		xmlSecSymbianCryptoX509SubjectNameNodeWrite	(X509* cert,

    59 								 xmlNodePtr node,

    60 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

    61 static int		xmlSecSymbianCryptoX509IssuerSerialNodeRead	(xmlSecKeyDataPtr data,

    62 								 xmlNodePtr node,

    63 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

    64 static int		xmlSecSymbianCryptoX509IssuerSerialNodeWrite	(X509* cert,

    65 								 xmlNodePtr node,

    66 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

    67 static int		xmlSecSymbianCryptoX509SKINodeRead		(xmlSecKeyDataPtr data,

    68 								 xmlNodePtr node,

    69 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

    70 static int		xmlSecSymbianCryptoX509SKINodeWrite		(X509* cert,

    71 								 xmlNodePtr node,

    72 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

    73 static int		xmlSecSymbianCryptoX509CRLNodeRead		(xmlSecKeyDataPtr data,

    74 								 xmlNodePtr node,

    75 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

    76 static int		xmlSecSymbianCryptoX509CRLNodeWrite		(X509_CRL* crl,

    77 								 xmlNodePtr node,

    78 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

    79 static int		xmlSecSymbianCryptoKeyDataX509VerifyAndExtractKey(xmlSecKeyDataPtr data, 

    80 								xmlSecKeyPtr key,

    81 								xmlSecKeyInfoCtxPtr keyInfoCtx);

    82 static X509*		xmlSecSymbianCryptoX509CertDerRead		(const xmlSecByte* buf, 

    83 								 xmlSecSize size);

    84 static X509*		xmlSecSymbianCryptoX509CertBase64DerRead	(xmlChar* buf);

    85 static xmlChar*		xmlSecSymbianCryptoX509CertBase64DerWrite	(X509* cert, 

    86 								 int base64LineWrap);

    87 static X509_CRL*	xmlSecSymbianCryptoX509CrlDerRead		(xmlSecByte* buf, 

    88 								 xmlSecSize size);

    89 static X509_CRL*	xmlSecSymbianCryptoX509CrlBase64DerRead	(xmlChar* buf);

    90 static xmlChar*		xmlSecSymbianCryptoX509CrlBase64DerWrite	(X509_CRL* crl, 

    91 								 int base64LineWrap);

    92 static xmlChar*		xmlSecSymbianCryptoX509NameWrite		(X509_NAME* nm);

    93 #ifdef XMLSEC_FUTURE_SUPPORT

    94 static xmlChar*		xmlSecSymbianCryptoASN1IntegerWrite		(ASN1_INTEGER *asni);

    95 #endif //XMLSEC_FUTURE_SUPPORT

    96 static xmlChar*		xmlSecSymbianCryptoX509SKIWrite		(X509* cert);

    97 static void		xmlSecSymbianCryptoX509CertDebugDump		(X509* cert, 

    98 								 FILE* output);

    99 static void		xmlSecSymbianCryptoX509CertDebugXmlDump	(X509* cert, 

   100 								 FILE* output);

   101 #ifdef XMLSEC_FUTURE_SUPPORT								 

   102 static int		xmlSecSymbianCryptoX509CertGetTime		(ASN1_TIME* t,

   103 								 time_t* res);

   104 #endif //XMLSEC_FUTURE_SUPPORT

   105 /*************************************************************************

   106 *

   107 * Support for SymbianCertStore

   108 *

   109 *************************************************************************/

   110 static int XmlSecCertStoreFlag = 0;

   111 

   112 // ---------------------------------------------------------------------------

   113 // Set SymbianCertStore flag.

   114 // ---------------------------------------------------------------------------

   115 //

   116 EXPORT_C 

   117 void xmlSecSetCertStoreFlag()

   118     {

   119     XmlSecCertStoreFlag = 1;

   120     }

   121     

   122 // ---------------------------------------------------------------------------

   123 // Reset SymbianCertStore  flag.

   124 // ---------------------------------------------------------------------------

   125 //

   126 EXPORT_C 

   127 void xmlSecResetCertStoreFlag()

   128     {

   129     XmlSecCertStoreFlag = 0;

   130     }

   131 // ---------------------------------------------------------------------------

   132 // Check SymbianCertStore  flag.

   133 // ---------------------------------------------------------------------------

   134 //

   135 EXPORT_C 

   136 int xmlSecCheckCertStoreFlag()

   137     {

   138     return XmlSecCertStoreFlag;

   139     }    

   140 /*************************************************************************

   141  *

   142  * Internal SymbianCrypto X509 data CTX

   143  *

   144  ************************************************************************/

   145 typedef struct _xmlSecSymbianCryptoX509DataCtx		xmlSecSymbianCryptoX509DataCtx,

   146 							*xmlSecSymbianCryptoX509DataCtxPtr;

   147 struct _xmlSecSymbianCryptoX509DataCtx {

   148     X509*		keyCert;

   149     STACK_OF(X509)*	certsList;

   150     STACK_OF(X509_CRL)*	crlsList;

   151 };

   152 /**************************************************************************

   153  *

   154  * <dsig:X509Data> processing

   155  *

   156  *

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

   158  *

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

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

   161  * The content of X509Data is:

   162  *

   163  *  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:

   164  *  2.

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

   166  *	distinguished name/serial number pair that SHOULD be compliant 

   167  *	with RFC2253 [LDAP-DN],

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

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

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

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

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

   173  *	certificate, and

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

   175  *	of the elements above.

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

   177  *	revocation list (CRL) [X509v3].

   178  *

   179  * Any X509IssuerSerial, X509SKI, and X509SubjectName elements that appear 

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

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

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

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

   184  *

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

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

   187  * KeyInfo but MAY occur in multiple X509Data elements.

   188  *

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

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

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

   192  *

   193  * No ordering is implied by the above constraints.

   194  *

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

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

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

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

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

   200  * signature.

   201  *

   202  * Schema Definition

   203  *

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

   205  *  <complexType name="X509DataType">

   206  *    <sequence maxOccurs="unbounded">

   207  *      <choice>

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

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

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

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

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

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

   214  *      </choice>

   215  *    </sequence>

   216  *  </complexType>

   217  *  <complexType name="X509IssuerSerialType"> 

   218  *    <sequence> 

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

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

   221  *     </sequence>

   222  *  </complexType>

   223  *

   224  *  DTD

   225  *

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

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

   228  *    <!ELEMENT X509IssuerSerial (X509IssuerName, X509SerialNumber) >

   229  *    <!ELEMENT X509IssuerName (#PCDATA) >

   230  *    <!ELEMENT X509SubjectName (#PCDATA) >

   231  *    <!ELEMENT X509SerialNumber (#PCDATA) >

   232  *    <!ELEMENT X509SKI (#PCDATA) >

   233  *    <!ELEMENT X509Certificate (#PCDATA) >

   234  *    <!ELEMENT X509CRL (#PCDATA) >

   235  *

   236  * -----------------------------------------------------------------------

   237  *

   238  * xmlSecSymbianCryptoX509DataCtx is located after xmlSecTransform

   239  *

   240  *************************************************************************/

   241 #define xmlSecSymbianCryptoX509DataSize	\

   242     (sizeof(xmlSecKeyData) + sizeof(xmlSecSymbianCryptoX509DataCtx))	

   243 #define xmlSecSymbianCryptoX509DataGetCtx(data) \

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

   245 

   246 static int		xmlSecSymbianCryptoKeyDataX509Initialize	(xmlSecKeyDataPtr data);

   247 static int		xmlSecSymbianCryptoKeyDataX509Duplicate	(xmlSecKeyDataPtr dst,

   248 								 xmlSecKeyDataPtr src);

   249 static void		xmlSecSymbianCryptoKeyDataX509Finalize	(xmlSecKeyDataPtr data);

   250 static int		xmlSecSymbianCryptoKeyDataX509XmlRead		(xmlSecKeyDataId id,

   251 								 xmlSecKeyPtr key,

   252 								 xmlNodePtr node,

   253 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

   254 static int		xmlSecSymbianCryptoKeyDataX509XmlWrite	(xmlSecKeyDataId id,

   255 								 xmlSecKeyPtr key,

   256 								 xmlNodePtr node,

   257 								 xmlSecKeyInfoCtxPtr keyInfoCtx);

   258 static xmlSecKeyDataType xmlSecSymbianCryptoKeyDataX509GetType	(xmlSecKeyDataPtr data);

   259 static const xmlChar*	xmlSecSymbianCryptoKeyDataX509GetIdentifier	(xmlSecKeyDataPtr data);

   260 

   261 static void		xmlSecSymbianCryptoKeyDataX509DebugDump	(xmlSecKeyDataPtr data,

   262 								 FILE* output);

   263 static void		xmlSecSymbianCryptoKeyDataX509DebugXmlDump	(xmlSecKeyDataPtr data,

   264 								 FILE* output);

   265 

   266 

   267 

   268 static xmlSecKeyDataKlass xmlSecSymbianCryptoKeyDataX509Klass = {

   269     sizeof(xmlSecKeyDataKlass),

   270     xmlSecSymbianCryptoX509DataSize,

   271 

   272     /* data */

   273     xmlSecNameX509Data,

   274     xmlSecKeyDataUsageKeyInfoNode | xmlSecKeyDataUsageRetrievalMethodNodeXml, 

   275 						/* xmlSecKeyDataUsage usage; */

   276     xmlSecHrefX509Data,				/* const xmlChar* href; */

   277     xmlSecNodeX509Data,				/* const xmlChar* dataNodeName; */

   278     xmlSecDSigNs,				/* const xmlChar* dataNodeNs; */

   279     

   280     /* constructors/destructor */

   281     xmlSecSymbianCryptoKeyDataX509Initialize,		/* xmlSecKeyDataInitializeMethod initialize; */

   282     xmlSecSymbianCryptoKeyDataX509Duplicate,		/* xmlSecKeyDataDuplicateMethod duplicate; */

   283     xmlSecSymbianCryptoKeyDataX509Finalize,		/* xmlSecKeyDataFinalizeMethod finalize; */

   284     NULL,					/* xmlSecKeyDataGenerateMethod generate; */

   285 

   286     /* get info */

   287     xmlSecSymbianCryptoKeyDataX509GetType, 		/* xmlSecKeyDataGetTypeMethod getType; */

   288     NULL,					/* xmlSecKeyDataGetSizeMethod getSize; */

   289     xmlSecSymbianCryptoKeyDataX509GetIdentifier,	/* xmlSecKeyDataGetIdentifier getIdentifier; */    

   290 

   291     /* read/write */

   292     xmlSecSymbianCryptoKeyDataX509XmlRead,		/* xmlSecKeyDataXmlReadMethod xmlRead; */

   293     xmlSecSymbianCryptoKeyDataX509XmlWrite,		/* xmlSecKeyDataXmlWriteMethod xmlWrite; */

   294     NULL,					/* xmlSecKeyDataBinReadMethod binRead; */

   295     NULL,					/* xmlSecKeyDataBinWriteMethod binWrite; */

   296 

   297     /* debug */

   298     xmlSecSymbianCryptoKeyDataX509DebugDump,		/* xmlSecKeyDataDebugDumpMethod debugDump; */

   299     xmlSecSymbianCryptoKeyDataX509DebugXmlDump, 	/* xmlSecKeyDataDebugDumpMethod debugXmlDump; */

   300 

   301     /* reserved for the future */

   302     NULL,					/* void* reserved0; */

   303     NULL,					/* void* reserved1; */

   304 };

   305 

   306 /** 

   307  * xmlSecSymbianCryptoKeyDataX509GetKlass:

   308  * 

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

   310  *

   311  * Returns the X509 data klass.

   312  */

   313 EXPORT_C

   314 xmlSecKeyDataId 

   315 xmlSecSymbianCryptoKeyDataX509GetKlass(void) {

   316     return(&xmlSecSymbianCryptoKeyDataX509Klass);

   317 }

   318 

   319 /**

   320  * xmlSecSymbianCryptoKeyDataX509GetKeyCert:

   321  * @data:		the pointer to X509 key data.

   322  *

   323  * Gets the certificate from which the key was extracted. 

   324  *

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

   326  * extraction or an error occurs.

   327  */

   328 EXPORT_C

   329 X509* 	

   330 xmlSecSymbianCryptoKeyDataX509GetKeyCert(xmlSecKeyDataPtr data) {

   331     xmlSecSymbianCryptoX509DataCtxPtr ctx;

   332     

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

   334 

   335     ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

   336     xmlSecAssert2(ctx, NULL);

   337 

   338     return(ctx->keyCert);

   339 }

   340 

   341 /**

   342  * xmlSecSymbianCryptoKeyDataX509AdoptKeyCert:

   343  * @data:		the pointer to X509 key data.

   344  * @cert:		the pointer to SymbianCrypto X509 certificate.

   345  *

   346  * Sets the key's certificate in @data.

   347  *

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

   349  */

   350 EXPORT_C

   351 int

   352 xmlSecSymbianCryptoKeyDataX509AdoptKeyCert(xmlSecKeyDataPtr data, X509* cert) {

   353     xmlSecSymbianCryptoX509DataCtxPtr ctx;

   354 

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

   356     xmlSecAssert2(cert, -1);

   357 

   358     ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

   359     xmlSecAssert2(ctx, -1);

   360     

   361     if(ctx->keyCert) {

   362 	X509_free(ctx->keyCert);

   363     }

   364     ctx->keyCert = cert;

   365     return(0);

   366 }

   367 

   368 /**

   369  * xmlSecSymbianCryptoKeyDataX509AdoptCert:

   370  * @data:		the pointer to X509 key data.

   371  * @cert:		the pointer to SymbianCrypto X509 certificate.

   372  *

   373  * Adds certificate to the X509 key data.

   374  *

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

   376  */

   377 EXPORT_C

   378 int 

   379 xmlSecSymbianCryptoKeyDataX509AdoptCert(xmlSecKeyDataPtr data, X509* cert) {

   380     xmlSecSymbianCryptoX509DataCtxPtr ctx;

   381     int ret;

   382     

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

   384     xmlSecAssert2(cert, -1);

   385 

   386     ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

   387     xmlSecAssert2(ctx, -1);

   388     /*

   389     if(ctx->certsList == NULL) {

   390 	ctx->certsList = sk_X509_new_null();

   391 	if(ctx->certsList == NULL) {

   392 	    xmlSecError(XMLSEC_ERRORS_HERE,

   393 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

   394 			"sk_X509_new_null",

   395 			XMLSEC_ERRORS_R_CRYPTO_FAILED,

   396 			XMLSEC_ERRORS_NO_MESSAGE);

   397 	    return(-1);	

   398 	}

   399     }

   400     

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

   402     if(ret < 1) {

   403 	xmlSecError(XMLSEC_ERRORS_HERE,

   404 		    xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

   405 		    "sk_X509_push",

   406 		    XMLSEC_ERRORS_R_CRYPTO_FAILED,

   407 		    XMLSEC_ERRORS_NO_MESSAGE);

   408 	return(-1);	

   409     }

   410     */

   411     return(0);

   412 }

   413 

   414 /**

   415  * xmlSecSymbianCryptoKeyDataX509GetCert:

   416  * @data:		the pointer to X509 key data.

   417  * @pos:		the desired certificate position.

   418  * 

   419  * Gets a certificate from X509 key data.

   420  *

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

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

   423  */

   424 EXPORT_C

   425 X509* 

   426 xmlSecSymbianCryptoKeyDataX509GetCert(xmlSecKeyDataPtr data, xmlSecSize pos) {

   427     xmlSecSymbianCryptoX509DataCtxPtr ctx;

   428 

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

   430 

   431     ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

   432     xmlSecAssert2(ctx, NULL);

   433     xmlSecAssert2(ctx->certsList, NULL);

   434 

   435     return NULL;

   436 }

   437 

   438 /**

   439  * xmlSecSymbianCryptoKeyDataX509GetCertsSize:

   440  * @data:		the pointer to X509 key data.

   441  *

   442  * Gets the number of certificates in @data.

   443  *

   444  * Returns te number of certificates in @data.

   445  */

   446 EXPORT_C

   447 xmlSecSize 	

   448 xmlSecSymbianCryptoKeyDataX509GetCertsSize(xmlSecKeyDataPtr data) {

   449     xmlSecSymbianCryptoX509DataCtxPtr ctx;

   450 

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

   452 

   453     ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

   454     xmlSecAssert2(ctx, 0);

   455 

   456    return 0;

   457 }

   458 

   459 /**

   460  * xmlSecSymbianCryptoKeyDataX509AdoptCrl:

   461  * @data:		the pointer to X509 key data.

   462  * @crl:		the pointer to SymbianCrypto X509 CRL.

   463  *

   464  * Adds CRL to the X509 key data.

   465  *

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

   467  */

   468 EXPORT_C

   469 int 

   470 xmlSecSymbianCryptoKeyDataX509AdoptCrl(xmlSecKeyDataPtr data, X509_CRL* crl) {

   471     xmlSecSymbianCryptoX509DataCtxPtr ctx;

   472     int ret;

   473     

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

   475     xmlSecAssert2(crl, -1);

   476 

   477     ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

   478     xmlSecAssert2(ctx, -1);

   479     /*

   480     if(ctx->crlsList == NULL) {

   481 	ctx->crlsList = sk_X509_CRL_new_null();

   482 	if(ctx->crlsList == NULL) {

   483 	    xmlSecError(XMLSEC_ERRORS_HERE,

   484 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

   485 			"sk_X509_CRL_new_null",

   486 			XMLSEC_ERRORS_R_CRYPTO_FAILED,

   487 			XMLSEC_ERRORS_NO_MESSAGE);

   488 	    return(-1);	

   489 	}

   490     }

   491     

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

   493     if(ret < 1) {

   494 	xmlSecError(XMLSEC_ERRORS_HERE,

   495 		    xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

   496 		    "sk_X509_CRL_push",

   497 		    XMLSEC_ERRORS_R_CRYPTO_FAILED,

   498 		    XMLSEC_ERRORS_NO_MESSAGE);

   499 	return(-1);	

   500     }

   501     */

   502     return(0);

   503 }

   504 

   505 /**

   506  * xmlSecSymbianCryptoKeyDataX509GetCrl:

   507  * @data:		the pointer to X509 key data.

   508  * @pos:		the desired CRL position.

   509  * 

   510  * Gets a CRL from X509 key data.

   511  *

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

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

   514  */

   515 EXPORT_C

   516 X509_CRL* 

   517 xmlSecSymbianCryptoKeyDataX509GetCrl(xmlSecKeyDataPtr data, xmlSecSize pos) {

   518     xmlSecSymbianCryptoX509DataCtxPtr ctx;

   519 

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

   521 

   522     ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

   523     xmlSecAssert2(ctx, NULL);

   524 

   525     xmlSecAssert2(ctx->crlsList, NULL);

   526 

   527    return NULL;

   528 }

   529 

   530 /**

   531  * xmlSecSymbianCryptoKeyDataX509GetCrlsSize:

   532  * @data:		the pointer to X509 key data.

   533  *

   534  * Gets the number of CRLs in @data.

   535  *

   536  * Returns te number of CRLs in @data.

   537  */

   538 EXPORT_C

   539 xmlSecSize 

   540 xmlSecSymbianCryptoKeyDataX509GetCrlsSize(xmlSecKeyDataPtr data) {

   541     xmlSecSymbianCryptoX509DataCtxPtr ctx;

   542 

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

   544 

   545     ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

   546     xmlSecAssert2(ctx, 0);

   547 

   548    return 0;

   549 }

   550 

   551 static int	

   552 xmlSecSymbianCryptoKeyDataX509Initialize(xmlSecKeyDataPtr data) {

   553     xmlSecSymbianCryptoX509DataCtxPtr ctx;

   554 

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

   556 

   557     ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

   558     xmlSecAssert2(ctx, -1);

   559 

   560     memset(ctx, 0, sizeof(xmlSecSymbianCryptoX509DataCtx));

   561     return(0);

   562 }

   563 

   564 static int

   565 xmlSecSymbianCryptoKeyDataX509Duplicate(xmlSecKeyDataPtr dst, xmlSecKeyDataPtr src) {

   566     X509* certSrc;

   567     X509* certDst = NULL;

   568     X509_CRL* crlSrc;

   569     X509_CRL* crlDst = NULL;

   570     xmlSecSize size, pos;

   571     int ret;

   572 

   573     xmlSecAssert2(xmlSecKeyDataCheckId(dst, xmlSecSymbianCryptoKeyDataX509Id), -1);

   574     xmlSecAssert2(xmlSecKeyDataCheckId(src, xmlSecSymbianCryptoKeyDataX509Id), -1);

   575     

   576     /* copy certsList */

   577     size = xmlSecSymbianCryptoKeyDataX509GetCertsSize(src);

   578     for(pos = 0; pos < size; ++pos) {

   579 	certSrc = xmlSecSymbianCryptoKeyDataX509GetCert(src, pos);

   580 	if(!certSrc) {

   581 	    xmlSecError(XMLSEC_ERRORS_HERE,

   582 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(src)),

   583 			"xmlSecSymbianCryptoKeyDataX509GetCert",

   584 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   585 			"pos=%d", pos);

   586 	    return(-1);

   587 	}

   588 	

   589 	if(!certDst) {

   590 	    xmlSecError(XMLSEC_ERRORS_HERE,

   591 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(dst)),

   592 			"X509_dup",

   593 			XMLSEC_ERRORS_R_CRYPTO_FAILED,

   594 			XMLSEC_ERRORS_NO_MESSAGE);

   595 	    return(-1);

   596 	}

   597 	

   598 	ret = xmlSecSymbianCryptoKeyDataX509AdoptCert(dst, certDst);

   599 	if(ret < 0) {

   600 	    xmlSecError(XMLSEC_ERRORS_HERE,

   601 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(dst)),

   602 			"xmlSecSymbianCryptoKeyDataX509AdoptCert",

   603 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   604 			XMLSEC_ERRORS_NO_MESSAGE);

   605 	    return(-1);

   606 	}

   607     }

   608 

   609     /* copy crls */

   610     size = xmlSecSymbianCryptoKeyDataX509GetCrlsSize(src);

   611     for(pos = 0; pos < size; ++pos) {

   612 	crlSrc = xmlSecSymbianCryptoKeyDataX509GetCrl(src, pos);

   613 	if(!crlSrc) {

   614 	    xmlSecError(XMLSEC_ERRORS_HERE,

   615 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(src)),

   616 			"xmlSecSymbianCryptoKeyDataX509GetCrl",

   617 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   618 			"pos=%d", pos);

   619 	    return(-1);

   620 	}

   621 	

   622 	if(!crlDst) {

   623 	    xmlSecError(XMLSEC_ERRORS_HERE,

   624 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(dst)),

   625 			"X509_CRL_dup",

   626 			XMLSEC_ERRORS_R_CRYPTO_FAILED,

   627 			XMLSEC_ERRORS_NO_MESSAGE);

   628 	    return(-1);

   629 	}

   630 	

   631 	ret = xmlSecSymbianCryptoKeyDataX509AdoptCrl(dst, crlDst);

   632 	if(ret < 0) {

   633 	    xmlSecError(XMLSEC_ERRORS_HERE,

   634 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(dst)),

   635 			"xmlSecSymbianCryptoKeyDataX509AdoptCrl",

   636 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   637 			XMLSEC_ERRORS_NO_MESSAGE);

   638 	    return(-1);

   639 	}

   640     }

   641 

   642     /* copy key cert if exist */

   643     certSrc = xmlSecSymbianCryptoKeyDataX509GetKeyCert(src);

   644     if(certSrc) {

   645 	if(!certDst) {

   646 	    xmlSecError(XMLSEC_ERRORS_HERE,

   647 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(dst)),

   648 			"X509_dup",

   649 			XMLSEC_ERRORS_R_CRYPTO_FAILED,

   650 			XMLSEC_ERRORS_NO_MESSAGE);

   651 	    return(-1);

   652 	}

   653 	ret = xmlSecSymbianCryptoKeyDataX509AdoptKeyCert(dst, certDst);

   654 	if(ret < 0) {

   655 	    xmlSecError(XMLSEC_ERRORS_HERE,

   656 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(dst)),

   657 			"xmlSecSymbianCryptoKeyDataX509AdoptKeyCert",

   658 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   659 			XMLSEC_ERRORS_NO_MESSAGE);

   660 	    return(-1);

   661 	}

   662     }

   663     return(0);

   664 }

   665 

   666 static void

   667 xmlSecSymbianCryptoKeyDataX509Finalize(xmlSecKeyDataPtr data) {

   668     xmlSecSymbianCryptoX509DataCtxPtr ctx;

   669 

   670     xmlSecAssert(xmlSecKeyDataCheckId(data, xmlSecSymbianCryptoKeyDataX509Id));

   671 

   672     ctx = xmlSecSymbianCryptoX509DataGetCtx(data);

   673     xmlSecAssert(ctx);

   674 

   675     if(ctx->certsList) {

   676 	

   677     }

   678     if(ctx->crlsList) {

   679 

   680     }

   681     if(ctx->keyCert) {

   682 	X509_free(ctx->keyCert);

   683     }

   684     memset(ctx, 0, sizeof(xmlSecSymbianCryptoX509DataCtx));

   685 }

   686 

   687 static int

   688 xmlSecSymbianCryptoKeyDataX509XmlRead(xmlSecKeyDataId id, xmlSecKeyPtr key,

   689 				xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx) {

   690     xmlSecKeyDataPtr data;

   691     int ret;

   692     

   693     xmlSecAssert2(id == xmlSecSymbianCryptoKeyDataX509Id, -1);

   694     xmlSecAssert2(key, -1);

   695     xmlSecAssert2(node, -1);

   696     xmlSecAssert2(keyInfoCtx, -1);

   697     

   698     data = xmlSecKeyEnsureData(key, id);

   699     if(!data) {

   700 	xmlSecError(XMLSEC_ERRORS_HERE,

   701 		    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

   702 		    "xmlSecKeyEnsureData",

   703 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   704 		    XMLSEC_ERRORS_NO_MESSAGE);

   705 	return(-1);

   706     }

   707     

   708     ret = xmlSecSymbianCryptoX509DataNodeRead(data, node, keyInfoCtx);

   709     if(ret < 0) {

   710 	xmlSecError(XMLSEC_ERRORS_HERE,

   711 		    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

   712 		    "xmlSecSymbianCryptoX509DataNodeRead",

   713 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   714 		    XMLSEC_ERRORS_NO_MESSAGE);

   715 	return(-1);

   716     }

   717 

   718     if((keyInfoCtx->flags & XMLSEC_KEYINFO_FLAGS_X509DATA_DONT_VERIFY_CERTS) == 0) {

   719         ret = xmlSecSymbianCryptoKeyDataX509VerifyAndExtractKey(data, key, keyInfoCtx);

   720 	if(ret < 0) {

   721 	    xmlSecError(XMLSEC_ERRORS_HERE,

   722 		        xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

   723 			"xmlSecSymbianCryptoKeyDataX509VerifyAndExtractKey",

   724 		        XMLSEC_ERRORS_R_XMLSEC_FAILED,

   725 			XMLSEC_ERRORS_NO_MESSAGE);

   726 	    return(-1);

   727         }

   728     }

   729     return(0);

   730 }

   731 

   732 static int 

   733 xmlSecSymbianCryptoKeyDataX509XmlWrite(xmlSecKeyDataId id, xmlSecKeyPtr key,

   734 				xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx) {

   735     xmlSecKeyDataPtr data;

   736     X509* cert;

   737     X509_CRL* crl;

   738     xmlSecSize size, pos = 0;

   739     int content;

   740     int ret;

   741     			

   742     xmlSecAssert2(id == xmlSecSymbianCryptoKeyDataX509Id, -1);

   743     xmlSecAssert2(key, -1);

   744     xmlSecAssert2(node, -1);

   745     xmlSecAssert2(keyInfoCtx, -1);

   746 

   747     content = xmlSecX509DataGetNodeContent (node, 1, keyInfoCtx);

   748     if (content < 0) {

   749 	xmlSecError(XMLSEC_ERRORS_HERE,

   750 		    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

   751 		    "xmlSecX509DataGetNodeContent",

   752 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   753 		    "content=%d", content);

   754 	return(-1);

   755     } else if(content == 0) {

   756 	/* by default we are writing certificates and crls */

   757 	content = XMLSEC_X509DATA_DEFAULT;

   758     }

   759 

   760     /* get x509 data */

   761     data = xmlSecKeyGetData(key, id);

   762     if(!data) {

   763 	/* no x509 data in the key */

   764 	return(0);	

   765     }

   766 

   767     /* write certs */   

   768     

   769 //    for(pos = 0; pos < size; ++pos) {

   770 	cert = xmlSecSymbianCryptoKeyDataX509GetKeyCert(data);

   771 	if(!cert) {

   772 	    xmlSecError(XMLSEC_ERRORS_HERE,

   773 			xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

   774 			"xmlSecSymbianCryptoKeyDataX509GetCert",

   775 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   776 			"pos=%d", pos);

   777 	    return(-1);

   778 	}

   779 	

   780 	if((content & XMLSEC_X509DATA_CERTIFICATE_NODE) != 0) {

   781 	    ret = xmlSecSymbianCryptoX509CertificateNodeWrite(cert, node, keyInfoCtx);

   782 	    if(ret < 0) {

   783 		xmlSecError(XMLSEC_ERRORS_HERE,

   784 			    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

   785 			    "xmlSecSymbianCryptoX509CertificateNodeWrite",

   786 			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   787 			    "pos=%d", pos);

   788 		return(-1);

   789 	    }

   790 	}

   791 

   792 	if((content & XMLSEC_X509DATA_SUBJECTNAME_NODE) != 0) {

   793 	    ret = xmlSecSymbianCryptoX509SubjectNameNodeWrite(cert, node, keyInfoCtx);

   794 	    if(ret < 0) {

   795 		xmlSecError(XMLSEC_ERRORS_HERE,

   796 			    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

   797 			    "xmlSecSymbianCryptoX509SubjectNameNodeWrite",

   798 			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   799 			    "pos=%d", pos);

   800 		return(-1);

   801 	    }

   802 	}

   803 

   804 	if((content & XMLSEC_X509DATA_ISSUERSERIAL_NODE) != 0) {

   805 	    ret = xmlSecSymbianCryptoX509IssuerSerialNodeWrite(cert, node, keyInfoCtx);

   806 	    if(ret < 0) {

   807 		xmlSecError(XMLSEC_ERRORS_HERE,

   808 			    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

   809 			    "xmlSecSymbianCryptoX509IssuerSerialNodeWrite",

   810 			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   811 			    "pos=%d", pos);

   812 		return(-1);

   813 	    }

   814 	}

   815 

   816 	if((content & XMLSEC_X509DATA_SKI_NODE) != 0) {

   817 	    ret = xmlSecSymbianCryptoX509SKINodeWrite(cert, node, keyInfoCtx);

   818 	    if(ret < 0) {

   819 		xmlSecError(XMLSEC_ERRORS_HERE,

   820 			    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

   821 			    "xmlSecSymbianCryptoX509SKINodeWrite",

   822 			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   823 			    "pos=%d", pos);

   824 		return(-1);

   825 	    }

   826 	}

   827 

   828 //    }    // for(pos = 0; pos < size; ++pos) 

   829 	

   830     /* write crls if needed */   

   831     if((content & XMLSEC_X509DATA_CRL_NODE) != 0) {

   832 	size = xmlSecSymbianCryptoKeyDataX509GetCrlsSize(data);

   833 	for(pos = 0; pos < size; ++pos) {

   834 	    crl = xmlSecSymbianCryptoKeyDataX509GetCrl(data, pos);

   835 	    if(!crl) {

   836 		xmlSecError(XMLSEC_ERRORS_HERE,

   837 			    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

   838 			    "xmlSecSymbianCryptoKeyDataX509GetCrl",

   839 			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   840 			    "pos=%d", pos);

   841 		return(-1);

   842 	    }

   843 	    

   844 	    ret = xmlSecSymbianCryptoX509CRLNodeWrite(crl, node, keyInfoCtx);

   845 	    if(ret < 0) {

   846 		xmlSecError(XMLSEC_ERRORS_HERE,

   847 			    xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),

   848 			    "xmlSecSymbianCryptoX509CRLNodeWrite",

   849 			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   850 			    "pos=%d", pos);

   851 		return(-1);

   852 	    }

   853 	}	

   854     }

   855    

   856     return(0);

   857 }

   858 

   859 

   860 static xmlSecKeyDataType

   861 xmlSecSymbianCryptoKeyDataX509GetType(xmlSecKeyDataPtr data) {

   862     xmlSecAssert2(xmlSecKeyDataCheckId(data, xmlSecSymbianCryptoKeyDataX509Id), 

   863                                                                    xmlSecKeyDataTypeUnknown);

   864 

   865     return(xmlSecKeyDataTypeUnknown);

   866 }

   867 

   868 static const xmlChar*

   869 xmlSecSymbianCryptoKeyDataX509GetIdentifier(xmlSecKeyDataPtr data) {

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

   871     

   872     return(NULL);

   873 }

   874 

   875 static void 

   876 xmlSecSymbianCryptoKeyDataX509DebugDump(xmlSecKeyDataPtr data, FILE* output) {

   877     X509* cert;

   878     xmlSecSize size, pos;

   879 

   880     xmlSecAssert(xmlSecKeyDataCheckId(data, xmlSecSymbianCryptoKeyDataX509Id));

   881     xmlSecAssert(output);

   882 

   883     fprintf(output, "=== X509 Data:\n");

   884     cert = xmlSecSymbianCryptoKeyDataX509GetKeyCert(data);

   885     if(cert) {

   886 	fprintf(output, "==== Key Certificate:\n");

   887 	xmlSecSymbianCryptoX509CertDebugDump(cert, output);

   888     }

   889     

   890     size = xmlSecSymbianCryptoKeyDataX509GetCertsSize(data);

   891     for(pos = 0; pos < size; ++pos) {

   892 	cert = xmlSecSymbianCryptoKeyDataX509GetCert(data, pos);

   893 	if(!cert) {

   894 	    xmlSecError(XMLSEC_ERRORS_HERE,

   895 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

   896 			"xmlSecSymbianCryptoKeyDataX509GetCert",

   897 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   898 			"pos=%d", pos);

   899 	    return;

   900 	}

   901 	fprintf(output, "==== Certificate:\n");

   902 	xmlSecSymbianCryptoX509CertDebugDump(cert, output);

   903     }

   904     

   905     /* we don't print out crls */

   906 }

   907 

   908 static void

   909 xmlSecSymbianCryptoKeyDataX509DebugXmlDump(xmlSecKeyDataPtr data, FILE* output) {

   910     X509* cert;

   911     xmlSecSize size, pos;

   912 

   913     xmlSecAssert(xmlSecKeyDataCheckId(data, xmlSecSymbianCryptoKeyDataX509Id));

   914     xmlSecAssert(output);

   915 

   916     fprintf(output, "<X509Data>\n");

   917     cert = xmlSecSymbianCryptoKeyDataX509GetKeyCert(data);

   918     if(cert) {

   919 	fprintf(output, "<KeyCertificate>\n");

   920 	xmlSecSymbianCryptoX509CertDebugXmlDump(cert, output);

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

   922     }

   923     

   924     size = xmlSecSymbianCryptoKeyDataX509GetCertsSize(data);

   925     for(pos = 0; pos < size; ++pos) {

   926 	cert = xmlSecSymbianCryptoKeyDataX509GetCert(data, pos);

   927 	if(!cert) {

   928 	    xmlSecError(XMLSEC_ERRORS_HERE,

   929 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

   930 			"xmlSecSymbianCryptoKeyDataX509GetCert",

   931 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   932 			"pos=%d", pos);

   933 	    return;

   934 	}

   935 	fprintf(output, "<Certificate>\n");

   936 	xmlSecSymbianCryptoX509CertDebugXmlDump(cert, output);

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

   938     }

   939     

   940     /* we don't print out crls */

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

   942 }

   943 

   944 static int

   945 xmlSecSymbianCryptoX509DataNodeRead(xmlSecKeyDataPtr data, 

   946                                         xmlNodePtr node, 

   947                                         xmlSecKeyInfoCtxPtr keyInfoCtx) {

   948     xmlNodePtr cur; 

   949     int ret;

   950         

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

   952     xmlSecAssert2(node, -1);

   953     xmlSecAssert2(keyInfoCtx, -1);

   954     

   955     for(cur = xmlSecGetNextElementNode(node->children);

   956 	cur;

   957 	cur = xmlSecGetNextElementNode(cur->next)) {

   958 	

   959 	ret = 0;

   960 	if(xmlSecCheckNodeName(cur, xmlSecNodeX509Certificate, xmlSecDSigNs)) {

   961 	    ret = xmlSecSymbianCryptoX509CertificateNodeRead(data, cur, keyInfoCtx);

   962 	} else if(xmlSecCheckNodeName(cur, xmlSecNodeX509SubjectName, xmlSecDSigNs)) {

   963 	    ret = xmlSecSymbianCryptoX509SubjectNameNodeRead(data, cur, keyInfoCtx);

   964 	} else if(xmlSecCheckNodeName(cur, xmlSecNodeX509IssuerSerial, xmlSecDSigNs)) {

   965 	    ret = xmlSecSymbianCryptoX509IssuerSerialNodeRead(data, cur, keyInfoCtx);

   966 	} else if(xmlSecCheckNodeName(cur, xmlSecNodeX509SKI, xmlSecDSigNs)) {

   967 	    ret = xmlSecSymbianCryptoX509SKINodeRead(data, cur, keyInfoCtx);

   968 	} else if(xmlSecCheckNodeName(cur, xmlSecNodeX509CRL, xmlSecDSigNs)) {

   969 	    ret = xmlSecSymbianCryptoX509CRLNodeRead(data, cur, keyInfoCtx);

   970 	} else if((keyInfoCtx->flags & XMLSEC_KEYINFO_FLAGS_X509DATA_STOP_ON_UNKNOWN_CHILD) != 0) {

   971 	    /* laxi schema validation: ignore unknown nodes */

   972 	    xmlSecError(XMLSEC_ERRORS_HERE,

   973 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

   974 			xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),

   975 			XMLSEC_ERRORS_R_UNEXPECTED_NODE,

   976 			XMLSEC_ERRORS_NO_MESSAGE);

   977 	    return(-1);

   978 	}

   979 	if(ret < 0) {

   980 	    xmlSecError(XMLSEC_ERRORS_HERE,

   981 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

   982 			xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),

   983 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   984 			"read node failed");

   985 	    return(-1);  

   986 	}	

   987     }

   988     return(0);

   989 }

   990 

   991 static int

   992 xmlSecSymbianCryptoX509CertificateNodeRead(xmlSecKeyDataPtr data, 

   993                                     xmlNodePtr node, 

   994                                     xmlSecKeyInfoCtxPtr keyInfoCtx) {	

   995     xmlChar *content;

   996     X509* cert;

   997     int ret;

   998 

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

  1000     xmlSecAssert2(node, -1);

  1001     xmlSecAssert2(keyInfoCtx, -1);

  1002 

  1003     content = xmlNodeGetContent(node);

  1004     if((!content) || (xmlSecIsEmptyString(content) == 1)) {

  1005 	if(content) {

  1006 	    xmlFree(content);

  1007 	}

  1008 	if ( OOM_FLAG )

  1009 	    return(-1);

  1010 	if((keyInfoCtx->flags & XMLSEC_KEYINFO_FLAGS_STOP_ON_EMPTY_NODE) != 0) {

  1011 	    xmlSecError(XMLSEC_ERRORS_HERE,

  1012 			xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

  1013 			xmlSecErrorsSafeString(xmlSecNodeGetName(node)),

  1014 			XMLSEC_ERRORS_R_INVALID_NODE_CONTENT,

  1015 			XMLSEC_ERRORS_NO_MESSAGE);

  1016 	    return(-1);

  1017 	}

  1018 	return(0);

  1019     }

  1020 

  1021     cert = xmlSecSymbianCryptoX509CertBase64DerRead(content);

  1022     if(!cert) {

  1023 	xmlSecError(XMLSEC_ERRORS_HERE,

  1024 		    xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

  1025 		    "xmlSecSymbianCryptoX509CertBase64DerRead",

  1026 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

  1027 		    XMLSEC_ERRORS_NO_MESSAGE);

  1028 	xmlFree(content);

  1029 	return(-1);

  1030     }    

  1031     

  1032     ret = xmlSecSymbianCryptoKeyDataX509AdoptKeyCert(data, cert);

  1033     if(ret < 0) {

  1034 	xmlSecError(XMLSEC_ERRORS_HERE,

  1035 		    xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

  1036 		    "xmlSecSymbianCryptoKeyDataX509AdoptKeyCert",

  1037 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

  1038 		    XMLSEC_ERRORS_NO_MESSAGE);

  1039 	X509_free(cert);

  1040 	xmlFree(content);

  1041 	return(-1);

  1042     }

  1043      

  1044     xmlFree(content);

  1045     return(0);

  1046 }

  1047 

  1048 static int 

  1049 xmlSecSymbianCryptoX509CertificateNodeWrite(X509* cert, 

  1050                             xmlNodePtr node, 

  1051                             xmlSecKeyInfoCtxPtr keyInfoCtx) {

  1052     xmlChar* buf;

  1053     xmlNodePtr cur;

  1054     

  1055     xmlSecAssert2(cert, -1);

  1056     xmlSecAssert2(node, -1);

  1057     xmlSecAssert2(keyInfoCtx, -1);

  1058     

  1059     /* set base64 lines size from context */

  1060     buf = xmlSecSymbianCryptoX509CertBase64DerWrite(cert, keyInfoCtx->base64LineSize); 

  1061     if(!buf) {

  1062 	xmlSecError(XMLSEC_ERRORS_HERE,

  1063 		    NULL,

  1064 		    "xmlSecSymbianCryptoX509CertBase64DerWrite",

  1065 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

  1066 		    XMLSEC_ERRORS_NO_MESSAGE);

  1067 	return(-1);

  1068     }

  1069 	

  1070     cur = xmlSecAddChild(node, xmlSecNodeX509Certificate, xmlSecDSigNs);

  1071     if(!cur) {

  1072 	xmlSecError(XMLSEC_ERRORS_HERE,

  1073 		    NULL,

  1074 		    "xmlSecAddChild",

  1075 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

  1076 		    "node=%s",

  1077 		    xmlSecErrorsSafeString(xmlSecNodeX509Certificate));

  1078 	xmlFree(buf);

  1079 	return(-1);	

  1080     }

  1081 

  1082     xmlNodeSetContent(cur, xmlSecStringCR);

  1083     if ( OOM_FLAG )

  1084         {

  1085         xmlUnlinkNode(cur);

  1086 	    xmlFreeNode(cur);

  1087         xmlFree(buf);

  1088         return(-1);

  1089         }

  1090     xmlNodeSetContent(cur, buf);

  1091     if ( OOM_FLAG )

  1092         {

  1093         xmlUnlinkNode(cur);

  1094 	    xmlFreeNode(cur);

  1095         xmlFree(buf);

  1096         return(-1);

  1097         }

  1098     xmlFree(buf);

  1099     return(0);

  1100 }

  1101 

  1102 static int		

  1103 xmlSecSymbianCryptoX509SubjectNameNodeRead(xmlSecKeyDataPtr data, 

  1104                             xmlNodePtr node, 

  1105                             xmlSecKeyInfoCtxPtr keyInfoCtx) {	

  1106     xmlSecKeyDataStorePtr x509Store;

  1107     xmlChar* subject;

  1108     X509* cert;

  1109     X509* cert2 = NULL;

  1110     int ret;

  1111     

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

  1113     xmlSecAssert2(node, -1);

  1114     xmlSecAssert2(keyInfoCtx, -1);

  1115     xmlSecAssert2(keyInfoCtx->keysMngr, -1);

  1116 

  1117     x509Store = xmlSecKeysMngrGetDataStore(keyInfoCtx->keysMngr, xmlSecSymbianCryptoX509StoreId);

  1118     if(!x509Store) {

  1119 	xmlSecError(XMLSEC_ERRORS_HERE,

  1120 		    xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),

  1121 		    "xmlSecKeysMngrGetDataStore",

  1122 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

  1123 		    XMLSEC_ERRORS_NO_MESSAGE);

  1124 	return(-1);

  1125     }

  1126 

  1127     subject = xmlNodeGetContent(node);

  1128     if((!subject) || (xmlSecIsEmptyString(subject) == 1)) {

  1129 	if(subject) {

  1130 	    xmlFree(subject);

  1131 	}

  1132 	if((keyInfoCtx->flags & XMLSEC_KEYINFO_FLAGS_STOP_ON_EMPTY_NODE) != 0) {

  1133 	    xmlSecError(XMLSEC_ERRORS_HERE,

  1134 		        xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),