epoc32/include/stdapis/openssl/pem.h
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:33:34 +0100
branchSymbian3
changeset 4 837f303aceeb
parent 0 061f57f2323e
permissions -rw-r--r--
Current Symbian^3 public API header files (from PDK 3.0.h)
This is the epoc32/include tree with the "platform" subtrees removed, and
all but a selected few mbg and rsg files removed.
     1 /* crypto/pem/pem.h */
     2 /* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
     3  * All rights reserved.
     4  *
     5  * This package is an SSL implementation written
     6  * by Eric Young (eay@cryptsoft.com).
     7  * The implementation was written so as to conform with Netscapes SSL.
     8  * 
     9  * This library is free for commercial and non-commercial use as long as
    10  * the following conditions are aheared to.  The following conditions
    11  * apply to all code found in this distribution, be it the RC4, RSA,
    12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
    13  * included with this distribution is covered by the same copyright terms
    14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
    15  * 
    16  * Copyright remains Eric Young's, and as such any Copyright notices in
    17  * the code are not to be removed.
    18  * If this package is used in a product, Eric Young should be given attribution
    19  * as the author of the parts of the library used.
    20  * This can be in the form of a textual message at program startup or
    21  * in documentation (online or textual) provided with the package.
    22  * 
    23  * Redistribution and use in source and binary forms, with or without
    24  * modification, are permitted provided that the following conditions
    25  * are met:
    26  * 1. Redistributions of source code must retain the copyright
    27  *    notice, this list of conditions and the following disclaimer.
    28  * 2. Redistributions in binary form must reproduce the above copyright
    29  *    notice, this list of conditions and the following disclaimer in the
    30  *    documentation and/or other materials provided with the distribution.
    31  * 3. All advertising materials mentioning features or use of this software
    32  *    must display the following acknowledgement:
    33  *    "This product includes cryptographic software written by
    34  *     Eric Young (eay@cryptsoft.com)"
    35  *    The word 'cryptographic' can be left out if the rouines from the library
    36  *    being used are not cryptographic related :-).
    37  * 4. If you include any Windows specific code (or a derivative thereof) from 
    38  *    the apps directory (application code) you must include an acknowledgement:
    39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
    40  * 
    41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
    42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
    45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
    47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
    50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    51  * SUCH DAMAGE.
    52  * 
    53  * The licence and distribution terms for any publically available version or
    54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
    55  * copied and put under another distribution licence
    56  * [including the GNU Public Licence.]
    57  */
    58 /*
    59  © Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.
    60  */
    61 
    62 #ifndef HEADER_PEM_H
    63 #define HEADER_PEM_H
    64 
    65 #if (defined(__SYMBIAN32__) && !defined(SYMBIAN))
    66 #define SYMBIAN
    67 #endif
    68 
    69 #ifdef SYMBIAN
    70 #include <e32def.h>
    71 #endif
    72 #include <openssl/e_os2.h>
    73 #ifndef OPENSSL_NO_BIO
    74 #include <openssl/bio.h>
    75 #endif
    76 #ifndef OPENSSL_NO_STACK
    77 #include <openssl/stack.h>
    78 #endif
    79 #include <openssl/evp.h>
    80 #include <openssl/x509.h>
    81 #include <openssl/pem2.h>
    82 
    83 #ifdef  __cplusplus
    84 extern "C" {
    85 #endif
    86 
    87 #define PEM_BUFSIZE		1024
    88 
    89 #define PEM_OBJ_UNDEF		0
    90 #define PEM_OBJ_X509		1
    91 #define PEM_OBJ_X509_REQ	2
    92 #define PEM_OBJ_CRL		3
    93 #define PEM_OBJ_SSL_SESSION	4
    94 #define PEM_OBJ_PRIV_KEY	10
    95 #define PEM_OBJ_PRIV_RSA	11
    96 #define PEM_OBJ_PRIV_DSA	12
    97 #define PEM_OBJ_PRIV_DH		13
    98 #define PEM_OBJ_PUB_RSA		14
    99 #define PEM_OBJ_PUB_DSA		15
   100 #define PEM_OBJ_PUB_DH		16
   101 #define PEM_OBJ_DHPARAMS	17
   102 #define PEM_OBJ_DSAPARAMS	18
   103 #define PEM_OBJ_PRIV_RSA_PUBLIC	19
   104 #define PEM_OBJ_PRIV_ECDSA	20
   105 #define PEM_OBJ_PUB_ECDSA	21
   106 #define PEM_OBJ_ECPARAMETERS	22
   107 
   108 #define PEM_ERROR		30
   109 #define PEM_DEK_DES_CBC         40
   110 #define PEM_DEK_IDEA_CBC        45
   111 #define PEM_DEK_DES_EDE         50
   112 #define PEM_DEK_DES_ECB         60
   113 #define PEM_DEK_RSA             70
   114 #define PEM_DEK_RSA_MD2         80
   115 #define PEM_DEK_RSA_MD5         90
   116 
   117 #define PEM_MD_MD2		NID_md2
   118 #define PEM_MD_MD5		NID_md5
   119 #define PEM_MD_SHA		NID_sha
   120 #define PEM_MD_MD2_RSA		NID_md2WithRSAEncryption
   121 #define PEM_MD_MD5_RSA		NID_md5WithRSAEncryption
   122 #define PEM_MD_SHA_RSA		NID_sha1WithRSAEncryption
   123 
   124 #define PEM_STRING_X509_OLD	"X509 CERTIFICATE"
   125 #define PEM_STRING_X509		"CERTIFICATE"
   126 #define PEM_STRING_X509_PAIR	"CERTIFICATE PAIR"
   127 #define PEM_STRING_X509_TRUSTED	"TRUSTED CERTIFICATE"
   128 #define PEM_STRING_X509_REQ_OLD	"NEW CERTIFICATE REQUEST"
   129 #define PEM_STRING_X509_REQ	"CERTIFICATE REQUEST"
   130 #define PEM_STRING_X509_CRL	"X509 CRL"
   131 #define PEM_STRING_EVP_PKEY	"ANY PRIVATE KEY"
   132 #define PEM_STRING_PUBLIC	"PUBLIC KEY"
   133 #define PEM_STRING_RSA		"RSA PRIVATE KEY"
   134 #define PEM_STRING_RSA_PUBLIC	"RSA PUBLIC KEY"
   135 #define PEM_STRING_DSA		"DSA PRIVATE KEY"
   136 #define PEM_STRING_DSA_PUBLIC	"DSA PUBLIC KEY"
   137 #define PEM_STRING_PKCS7	"PKCS7"
   138 #define PEM_STRING_PKCS8	"ENCRYPTED PRIVATE KEY"
   139 #define PEM_STRING_PKCS8INF	"PRIVATE KEY"
   140 #define PEM_STRING_DHPARAMS	"DH PARAMETERS"
   141 #define PEM_STRING_SSL_SESSION	"SSL SESSION PARAMETERS"
   142 #define PEM_STRING_DSAPARAMS	"DSA PARAMETERS"
   143 #define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY"
   144 #define PEM_STRING_ECPARAMETERS "EC PARAMETERS"
   145 #define PEM_STRING_ECPRIVATEKEY	"EC PRIVATE KEY"
   146 
   147   /* Note that this structure is initialised by PEM_SealInit and cleaned up
   148      by PEM_SealFinal (at least for now) */
   149 typedef struct PEM_Encode_Seal_st
   150 	{
   151 	EVP_ENCODE_CTX encode;
   152 	EVP_MD_CTX md;
   153 	EVP_CIPHER_CTX cipher;
   154 	} PEM_ENCODE_SEAL_CTX;
   155 
   156 /* enc_type is one off */
   157 #define PEM_TYPE_ENCRYPTED      10
   158 #define PEM_TYPE_MIC_ONLY       20
   159 #define PEM_TYPE_MIC_CLEAR      30
   160 #define PEM_TYPE_CLEAR		40
   161 
   162 typedef struct pem_recip_st
   163 	{
   164 	char *name;
   165 	X509_NAME *dn;
   166 
   167 	int cipher;
   168 	int key_enc;
   169 	/*	char iv[8]; unused and wrong size */
   170 	} PEM_USER;
   171 
   172 typedef struct pem_ctx_st
   173 	{
   174 	int type;		/* what type of object */
   175 
   176 	struct	{
   177 		int version;	
   178 		int mode;		
   179 		} proc_type;
   180 
   181 	char *domain;
   182 
   183 	struct	{
   184 		int cipher;
   185 	/* unused, and wrong size
   186 	   unsigned char iv[8]; */
   187 		} DEK_info;
   188 		
   189 	PEM_USER *originator;
   190 
   191 	int num_recipient;
   192 	PEM_USER **recipient;
   193 
   194 #ifndef OPENSSL_NO_STACK
   195 	STACK *x509_chain;	/* certificate chain */
   196 #else
   197 	char *x509_chain;	/* certificate chain */
   198 #endif
   199 	EVP_MD *md;		/* signature type */
   200 
   201 	int md_enc;		/* is the md encrypted or not? */
   202 	int md_len;		/* length of md_data */
   203 	char *md_data;		/* message digest, could be pkey encrypted */
   204 
   205 	EVP_CIPHER *dec;	/* date encryption cipher */
   206 	int key_len;		/* key length */
   207 	unsigned char *key;	/* key */
   208 	/* unused, and wrong size
   209 	   unsigned char iv[8]; */
   210 
   211 	
   212 	int  data_enc;		/* is the data encrypted */
   213 	int data_len;
   214 	unsigned char *data;
   215 	} PEM_CTX;
   216 
   217 /* These macros make the PEM_read/PEM_write functions easier to maintain and
   218  * write. Now they are all implemented with either:
   219  * IMPLEMENT_PEM_rw(...) or IMPLEMENT_PEM_rw_cb(...)
   220  */
   221 
   222 #ifdef OPENSSL_NO_FP_API
   223 
   224 #define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/
   225 #define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/
   226 #define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/
   227 
   228 #else
   229 
   230 #define IMPLEMENT_PEM_read_fp(name, type, str, asn1) \
   231 EXPORT_C type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u)\
   232 { \
   233     return (type*)PEM_ASN1_read(CHECKED_D2I_OF(type, d2i_##asn1), \
   234 				str, fp, \
   235 				CHECKED_PPTR_OF(type, x), \
   236 				cb, u); \
   237 } 
   238 
   239 #define IMPLEMENT_PEM_write_fp(name, type, str, asn1) \
   240 EXPORT_C int PEM_write_##name(FILE *fp, type *x) \
   241 { \
   242     return PEM_ASN1_write(CHECKED_I2D_OF(type, i2d_##asn1), \
   243 			  str, fp, \
   244 			  CHECKED_PTR_OF(type, x), \
   245 			  NULL, NULL, 0, NULL, NULL); \
   246 }
   247 
   248 #define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \
   249 EXPORT_C int PEM_write_##name(FILE *fp, const type *x) \
   250 { \
   251     return PEM_ASN1_write(CHECKED_I2D_OF(const type, i2d_##asn1), \
   252 			  str, fp, \
   253 			  CHECKED_PTR_OF(const type, x), \
   254 			  NULL, NULL, 0, NULL, NULL); \
   255 }
   256 
   257 #define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) \
   258 EXPORT_C int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \
   259 	     unsigned char *kstr, int klen, pem_password_cb *cb, \
   260 		  void *u) \
   261 	{ \
   262 	    return PEM_ASN1_write(CHECKED_I2D_OF(type, i2d_##asn1), \
   263 				  str, fp, \
   264 				  CHECKED_PTR_OF(type, x), \
   265 				  enc, kstr, klen, cb, u); \
   266 	}
   267 
   268 #define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \
   269 EXPORT_C int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \
   270 	     unsigned char *kstr, int klen, pem_password_cb *cb, \
   271 		  void *u) \
   272 	{ \
   273 	    return PEM_ASN1_write(CHECKED_I2D_OF(const type, i2d_##asn1), \
   274 				  str, fp, \
   275 				  CHECKED_PTR_OF(const type, x), \
   276 				  enc, kstr, klen, cb, u); \
   277 	}
   278 
   279 #endif
   280 
   281 #define IMPLEMENT_PEM_read_bio(name, type, str, asn1) \
   282 EXPORT_C type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u)\
   283 { \
   284     return (type*)PEM_ASN1_read_bio(CHECKED_D2I_OF(type, d2i_##asn1), \
   285 				    str, bp, \
   286 				    CHECKED_PPTR_OF(type, x), \
   287 				    cb, u); \
   288 }
   289 
   290 #define IMPLEMENT_PEM_write_bio(name, type, str, asn1) \
   291 EXPORT_C int PEM_write_bio_##name(BIO *bp, type *x) \
   292 { \
   293     return PEM_ASN1_write_bio(CHECKED_I2D_OF(type, i2d_##asn1), \
   294 			      str, bp, \
   295 			      CHECKED_PTR_OF(type, x), \
   296 			      NULL, NULL, 0, NULL, NULL); \
   297 }
   298 
   299 #define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \
   300 EXPORT_C int PEM_write_bio_##name(BIO *bp, const type *x) \
   301 { \
   302     return PEM_ASN1_write_bio(CHECKED_I2D_OF(const type, i2d_##asn1), \
   303 			      str, bp, \
   304 			      CHECKED_PTR_OF(const type, x), \
   305 			      NULL, NULL, 0, NULL, NULL); \
   306 }
   307 
   308 #define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \
   309 EXPORT_C int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \
   310 	     unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \
   311 	{ \
   312 	    return PEM_ASN1_write_bio(CHECKED_I2D_OF(type, i2d_##asn1), \
   313 				      str, bp, \
   314 				      CHECKED_PTR_OF(type, x), \
   315 				      enc, kstr, klen, cb, u); \
   316 	}
   317 
   318 #define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \
   319 EXPORT_C int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \
   320 	     unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \
   321 	{ \
   322 	    return PEM_ASN1_write_bio(CHECKED_I2D_OF(const type, i2d_##asn1), \
   323 				      str, bp, \
   324 				      CHECKED_PTR_OF(const type, x), \
   325 				      enc, kstr, klen, cb, u); \
   326 	}
   327 
   328 #define IMPLEMENT_PEM_write(name, type, str, asn1) \
   329 	IMPLEMENT_PEM_write_bio(name, type, str, asn1) \
   330 	IMPLEMENT_PEM_write_fp(name, type, str, asn1) 
   331 
   332 #define IMPLEMENT_PEM_write_const(name, type, str, asn1) \
   333 	IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \
   334 	IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) 
   335 
   336 #define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \
   337 	IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \
   338 	IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) 
   339 
   340 #define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \
   341 	IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \
   342 	IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) 
   343 
   344 #define IMPLEMENT_PEM_read(name, type, str, asn1) \
   345 	IMPLEMENT_PEM_read_bio(name, type, str, asn1) \
   346 	IMPLEMENT_PEM_read_fp(name, type, str, asn1) 
   347 
   348 #define IMPLEMENT_PEM_rw(name, type, str, asn1) \
   349 	IMPLEMENT_PEM_read(name, type, str, asn1) \
   350 	IMPLEMENT_PEM_write(name, type, str, asn1)
   351 
   352 #define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \
   353 	IMPLEMENT_PEM_read(name, type, str, asn1) \
   354 	IMPLEMENT_PEM_write_const(name, type, str, asn1)
   355 
   356 #define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \
   357 	IMPLEMENT_PEM_read(name, type, str, asn1) \
   358 	IMPLEMENT_PEM_write_cb(name, type, str, asn1)
   359 
   360 /* These are the same except they are for the declarations */
   361 
   362 #if defined(OPENSSL_SYS_WIN16) || defined(OPENSSL_NO_FP_API)
   363 
   364 #define DECLARE_PEM_read_fp(name, type) /**/
   365 #define DECLARE_PEM_write_fp(name, type) /**/
   366 #define DECLARE_PEM_write_cb_fp(name, type) /**/
   367 
   368 #else
   369 
   370 #define DECLARE_PEM_read_fp(name, type) \
   371 	IMPORT_C type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u);
   372 
   373 #define DECLARE_PEM_write_fp(name, type) \
   374 	IMPORT_C int PEM_write_##name(FILE *fp, type *x);
   375 
   376 #define DECLARE_PEM_write_fp_const(name, type) \
   377 	IMPORT_C int PEM_write_##name(FILE *fp, const type *x);
   378 
   379 #define DECLARE_PEM_write_cb_fp(name, type) \
   380 	IMPORT_C int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \
   381 	     unsigned char *kstr, int klen, pem_password_cb *cb, void *u);
   382 
   383 #endif
   384 
   385 #ifndef OPENSSL_NO_BIO
   386 #define DECLARE_PEM_read_bio(name, type) \
   387 	IMPORT_C type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u);
   388 
   389 #define DECLARE_PEM_write_bio(name, type) \
   390 	IMPORT_C int PEM_write_bio_##name(BIO *bp, type *x);
   391 
   392 #define DECLARE_PEM_write_bio_const(name, type) \
   393 	IMPORT_C int PEM_write_bio_##name(BIO *bp, const type *x);
   394 
   395 #define DECLARE_PEM_write_cb_bio(name, type) \
   396 	IMPORT_C int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \
   397 	     unsigned char *kstr, int klen, pem_password_cb *cb, void *u);
   398 
   399 #else
   400 
   401 #define DECLARE_PEM_read_bio(name, type) /**/
   402 #define DECLARE_PEM_write_bio(name, type) /**/
   403 #define DECLARE_PEM_write_cb_bio(name, type) /**/
   404 
   405 #endif
   406 
   407 #define DECLARE_PEM_write(name, type) \
   408 	DECLARE_PEM_write_bio(name, type) \
   409 	DECLARE_PEM_write_fp(name, type) 
   410 
   411 #define DECLARE_PEM_write_const(name, type) \
   412 	DECLARE_PEM_write_bio_const(name, type) \
   413 	DECLARE_PEM_write_fp_const(name, type)
   414 
   415 #define DECLARE_PEM_write_cb(name, type) \
   416 	DECLARE_PEM_write_cb_bio(name, type) \
   417 	DECLARE_PEM_write_cb_fp(name, type) 
   418 
   419 #define DECLARE_PEM_read(name, type) \
   420 	DECLARE_PEM_read_bio(name, type) \
   421 	DECLARE_PEM_read_fp(name, type)
   422 
   423 #define DECLARE_PEM_rw(name, type) \
   424 	DECLARE_PEM_read(name, type) \
   425 	DECLARE_PEM_write(name, type)
   426 
   427 #define DECLARE_PEM_rw_const(name, type) \
   428 	DECLARE_PEM_read(name, type) \
   429 	DECLARE_PEM_write_const(name, type)
   430 
   431 #define DECLARE_PEM_rw_cb(name, type) \
   432 	DECLARE_PEM_read(name, type) \
   433 	DECLARE_PEM_write_cb(name, type)
   434 
   435 #ifdef SSLEAY_MACROS
   436 
   437 #define PEM_write_SSL_SESSION(fp,x) \
   438 		PEM_ASN1_write((int (*)())i2d_SSL_SESSION, \
   439 			PEM_STRING_SSL_SESSION,fp, (char *)x, NULL,NULL,0,NULL,NULL)
   440 #define PEM_write_X509(fp,x) \
   441 		PEM_ASN1_write((int (*)())i2d_X509,PEM_STRING_X509,fp, \
   442 			(char *)x, NULL,NULL,0,NULL,NULL)
   443 #define PEM_write_X509_REQ(fp,x) PEM_ASN1_write( \
   444 		(int (*)())i2d_X509_REQ,PEM_STRING_X509_REQ,fp,(char *)x, \
   445 			NULL,NULL,0,NULL,NULL)
   446 #define PEM_write_X509_CRL(fp,x) \
   447 		PEM_ASN1_write((int (*)())i2d_X509_CRL,PEM_STRING_X509_CRL, \
   448 			fp,(char *)x, NULL,NULL,0,NULL,NULL)
   449 #define	PEM_write_RSAPrivateKey(fp,x,enc,kstr,klen,cb,u) \
   450 		PEM_ASN1_write((int (*)())i2d_RSAPrivateKey,PEM_STRING_RSA,fp,\
   451 			(char *)x,enc,kstr,klen,cb,u)
   452 #define	PEM_write_RSAPublicKey(fp,x) \
   453 		PEM_ASN1_write((int (*)())i2d_RSAPublicKey,\
   454 			PEM_STRING_RSA_PUBLIC,fp,(char *)x,NULL,NULL,0,NULL,NULL)
   455 #define	PEM_write_DSAPrivateKey(fp,x,enc,kstr,klen,cb,u) \
   456 		PEM_ASN1_write((int (*)())i2d_DSAPrivateKey,PEM_STRING_DSA,fp,\
   457 			(char *)x,enc,kstr,klen,cb,u)
   458 #define	PEM_write_PrivateKey(bp,x,enc,kstr,klen,cb,u) \
   459 		PEM_ASN1_write((int (*)())i2d_PrivateKey,\
   460 		(((x)->type == EVP_PKEY_DSA)?PEM_STRING_DSA:PEM_STRING_RSA),\
   461 			bp,(char *)x,enc,kstr,klen,cb,u)
   462 #define PEM_write_PKCS7(fp,x) \
   463 		PEM_ASN1_write((int (*)())i2d_PKCS7,PEM_STRING_PKCS7,fp, \
   464 			(char *)x, NULL,NULL,0,NULL,NULL)
   465 #define PEM_write_DHparams(fp,x) \
   466 		PEM_ASN1_write((int (*)())i2d_DHparams,PEM_STRING_DHPARAMS,fp,\
   467 			(char *)x,NULL,NULL,0,NULL,NULL)
   468 
   469 #define PEM_write_NETSCAPE_CERT_SEQUENCE(fp,x) \
   470                 PEM_ASN1_write((int (*)())i2d_NETSCAPE_CERT_SEQUENCE, \
   471 			PEM_STRING_X509,fp, \
   472                         (char *)x, NULL,NULL,0,NULL,NULL)
   473 
   474 #define	PEM_read_SSL_SESSION(fp,x,cb,u) (SSL_SESSION *)PEM_ASN1_read( \
   475 	(char *(*)())d2i_SSL_SESSION,PEM_STRING_SSL_SESSION,fp,(char **)x,cb,u)
   476 #define	PEM_read_X509(fp,x,cb,u) (X509 *)PEM_ASN1_read( \
   477 	(char *(*)())d2i_X509,PEM_STRING_X509,fp,(char **)x,cb,u)
   478 #define	PEM_read_X509_REQ(fp,x,cb,u) (X509_REQ *)PEM_ASN1_read( \
   479 	(char *(*)())d2i_X509_REQ,PEM_STRING_X509_REQ,fp,(char **)x,cb,u)
   480 #define	PEM_read_X509_CRL(fp,x,cb,u) (X509_CRL *)PEM_ASN1_read( \
   481 	(char *(*)())d2i_X509_CRL,PEM_STRING_X509_CRL,fp,(char **)x,cb,u)
   482 #define	PEM_read_RSAPrivateKey(fp,x,cb,u) (RSA *)PEM_ASN1_read( \
   483 	(char *(*)())d2i_RSAPrivateKey,PEM_STRING_RSA,fp,(char **)x,cb,u)
   484 #define	PEM_read_RSAPublicKey(fp,x,cb,u) (RSA *)PEM_ASN1_read( \
   485 	(char *(*)())d2i_RSAPublicKey,PEM_STRING_RSA_PUBLIC,fp,(char **)x,cb,u)
   486 #define	PEM_read_DSAPrivateKey(fp,x,cb,u) (DSA *)PEM_ASN1_read( \
   487 	(char *(*)())d2i_DSAPrivateKey,PEM_STRING_DSA,fp,(char **)x,cb,u)
   488 #define	PEM_read_PrivateKey(fp,x,cb,u) (EVP_PKEY *)PEM_ASN1_read( \
   489 	(char *(*)())d2i_PrivateKey,PEM_STRING_EVP_PKEY,fp,(char **)x,cb,u)
   490 #define	PEM_read_PKCS7(fp,x,cb,u) (PKCS7 *)PEM_ASN1_read( \
   491 	(char *(*)())d2i_PKCS7,PEM_STRING_PKCS7,fp,(char **)x,cb,u)
   492 #define	PEM_read_DHparams(fp,x,cb,u) (DH *)PEM_ASN1_read( \
   493 	(char *(*)())d2i_DHparams,PEM_STRING_DHPARAMS,fp,(char **)x,cb,u)
   494 
   495 #define PEM_read_NETSCAPE_CERT_SEQUENCE(fp,x,cb,u) \
   496 		(NETSCAPE_CERT_SEQUENCE *)PEM_ASN1_read( \
   497         (char *(*)())d2i_NETSCAPE_CERT_SEQUENCE,PEM_STRING_X509,fp,\
   498 							(char **)x,cb,u)
   499 
   500 #define PEM_write_bio_X509(bp,x) \
   501 		PEM_ASN1_write_bio((int (*)())i2d_X509,PEM_STRING_X509,bp, \
   502 			(char *)x, NULL,NULL,0,NULL,NULL)
   503 #define PEM_write_bio_X509_REQ(bp,x) PEM_ASN1_write_bio( \
   504 		(int (*)())i2d_X509_REQ,PEM_STRING_X509_REQ,bp,(char *)x, \
   505 			NULL,NULL,0,NULL,NULL)
   506 #define PEM_write_bio_X509_CRL(bp,x) \
   507 		PEM_ASN1_write_bio((int (*)())i2d_X509_CRL,PEM_STRING_X509_CRL,\
   508 			bp,(char *)x, NULL,NULL,0,NULL,NULL)
   509 #define	PEM_write_bio_RSAPrivateKey(bp,x,enc,kstr,klen,cb,u) \
   510 		PEM_ASN1_write_bio((int (*)())i2d_RSAPrivateKey,PEM_STRING_RSA,\
   511 			bp,(char *)x,enc,kstr,klen,cb,u)
   512 #define	PEM_write_bio_RSAPublicKey(bp,x) \
   513 		PEM_ASN1_write_bio((int (*)())i2d_RSAPublicKey, \
   514 			PEM_STRING_RSA_PUBLIC,\
   515 			bp,(char *)x,NULL,NULL,0,NULL,NULL)
   516 #define	PEM_write_bio_DSAPrivateKey(bp,x,enc,kstr,klen,cb,u) \
   517 		PEM_ASN1_write_bio((int (*)())i2d_DSAPrivateKey,PEM_STRING_DSA,\
   518 			bp,(char *)x,enc,kstr,klen,cb,u)
   519 #define	PEM_write_bio_PrivateKey(bp,x,enc,kstr,klen,cb,u) \
   520 		PEM_ASN1_write_bio((int (*)())i2d_PrivateKey,\
   521 		(((x)->type == EVP_PKEY_DSA)?PEM_STRING_DSA:PEM_STRING_RSA),\
   522 			bp,(char *)x,enc,kstr,klen,cb,u)
   523 #define PEM_write_bio_PKCS7(bp,x) \
   524 		PEM_ASN1_write_bio((int (*)())i2d_PKCS7,PEM_STRING_PKCS7,bp, \
   525 			(char *)x, NULL,NULL,0,NULL,NULL)
   526 #define PEM_write_bio_DHparams(bp,x) \
   527 		PEM_ASN1_write_bio((int (*)())i2d_DHparams,PEM_STRING_DHPARAMS,\
   528 			bp,(char *)x,NULL,NULL,0,NULL,NULL)
   529 #define PEM_write_bio_DSAparams(bp,x) \
   530 		PEM_ASN1_write_bio((int (*)())i2d_DSAparams, \
   531 			PEM_STRING_DSAPARAMS,bp,(char *)x,NULL,NULL,0,NULL,NULL)
   532 
   533 #define PEM_write_bio_NETSCAPE_CERT_SEQUENCE(bp,x) \
   534                 PEM_ASN1_write_bio((int (*)())i2d_NETSCAPE_CERT_SEQUENCE, \
   535 			PEM_STRING_X509,bp, \
   536                         (char *)x, NULL,NULL,0,NULL,NULL)
   537 
   538 #define	PEM_read_bio_X509(bp,x,cb,u) (X509 *)PEM_ASN1_read_bio( \
   539 	(char *(*)())d2i_X509,PEM_STRING_X509,bp,(char **)x,cb,u)
   540 #define	PEM_read_bio_X509_REQ(bp,x,cb,u) (X509_REQ *)PEM_ASN1_read_bio( \
   541 	(char *(*)())d2i_X509_REQ,PEM_STRING_X509_REQ,bp,(char **)x,cb,u)
   542 #define	PEM_read_bio_X509_CRL(bp,x,cb,u) (X509_CRL *)PEM_ASN1_read_bio( \
   543 	(char *(*)())d2i_X509_CRL,PEM_STRING_X509_CRL,bp,(char **)x,cb,u)
   544 #define	PEM_read_bio_RSAPrivateKey(bp,x,cb,u) (RSA *)PEM_ASN1_read_bio( \
   545 	(char *(*)())d2i_RSAPrivateKey,PEM_STRING_RSA,bp,(char **)x,cb,u)
   546 #define	PEM_read_bio_RSAPublicKey(bp,x,cb,u) (RSA *)PEM_ASN1_read_bio( \
   547 	(char *(*)())d2i_RSAPublicKey,PEM_STRING_RSA_PUBLIC,bp,(char **)x,cb,u)
   548 #define	PEM_read_bio_DSAPrivateKey(bp,x,cb,u) (DSA *)PEM_ASN1_read_bio( \
   549 	(char *(*)())d2i_DSAPrivateKey,PEM_STRING_DSA,bp,(char **)x,cb,u)
   550 #define	PEM_read_bio_PrivateKey(bp,x,cb,u) (EVP_PKEY *)PEM_ASN1_read_bio( \
   551 	(char *(*)())d2i_PrivateKey,PEM_STRING_EVP_PKEY,bp,(char **)x,cb,u)
   552 
   553 #define	PEM_read_bio_PKCS7(bp,x,cb,u) (PKCS7 *)PEM_ASN1_read_bio( \
   554 	(char *(*)())d2i_PKCS7,PEM_STRING_PKCS7,bp,(char **)x,cb,u)
   555 #define	PEM_read_bio_DHparams(bp,x,cb,u) (DH *)PEM_ASN1_read_bio( \
   556 	(char *(*)())d2i_DHparams,PEM_STRING_DHPARAMS,bp,(char **)x,cb,u)
   557 #define	PEM_read_bio_DSAparams(bp,x,cb,u) (DSA *)PEM_ASN1_read_bio( \
   558 	(char *(*)())d2i_DSAparams,PEM_STRING_DSAPARAMS,bp,(char **)x,cb,u)
   559 
   560 #define PEM_read_bio_NETSCAPE_CERT_SEQUENCE(bp,x,cb,u) \
   561 		(NETSCAPE_CERT_SEQUENCE *)PEM_ASN1_read_bio( \
   562         (char *(*)())d2i_NETSCAPE_CERT_SEQUENCE,PEM_STRING_X509,bp,\
   563 							(char **)x,cb,u)
   564 
   565 #endif
   566 
   567 #if 1
   568 /* "userdata": new with OpenSSL 0.9.4 */
   569 typedef int pem_password_cb(char *buf, int size, int rwflag, void *userdata);
   570 #else
   571 /* OpenSSL 0.9.3, 0.9.3a */
   572 typedef int pem_password_cb(char *buf, int size, int rwflag);
   573 #endif
   574 
   575 IMPORT_C int	PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher);
   576 IMPORT_C int	PEM_do_header (EVP_CIPHER_INFO *cipher, unsigned char *data,long *len,
   577 	pem_password_cb *callback,void *u);
   578 
   579 #ifndef OPENSSL_NO_BIO
   580 IMPORT_C int	PEM_read_bio(BIO *bp, char **name, char **header,
   581 		unsigned char **data,long *len);
   582 IMPORT_C int	PEM_write_bio(BIO *bp,const char *name,char *hdr,unsigned char *data,
   583 		long len);
   584 IMPORT_C int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, const char *name, BIO *bp,
   585 	     pem_password_cb *cb, void *u);
   586 IMPORT_C void *	PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp,
   587 			  void **x, pem_password_cb *cb, void *u);
   588 
   589 #define PEM_ASN1_read_bio_of(type,d2i,name,bp,x,cb,u) \
   590     ((type*)PEM_ASN1_read_bio(CHECKED_D2I_OF(type, d2i), \
   591 			      name, bp,			\
   592 			      CHECKED_PPTR_OF(type, x), \
   593 			      cb, u))
   594 
   595 IMPORT_C int	PEM_ASN1_write_bio(i2d_of_void *i2d,const char *name,BIO *bp,char *x,
   596 			   const EVP_CIPHER *enc,unsigned char *kstr,int klen,
   597 			   pem_password_cb *cb, void *u);
   598 
   599 #define PEM_ASN1_write_bio_of(type,i2d,name,bp,x,enc,kstr,klen,cb,u) \
   600     (PEM_ASN1_write_bio(CHECKED_I2D_OF(type, i2d), \
   601 			name, bp,		   \
   602 			CHECKED_PTR_OF(type, x), \
   603 			enc, kstr, klen, cb, u))
   604 
   605 IMPORT_C STACK_OF(X509_INFO) *	PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb, void *u);
   606 IMPORT_C int	PEM_X509_INFO_write_bio(BIO *bp,X509_INFO *xi, EVP_CIPHER *enc,
   607 		unsigned char *kstr, int klen, pem_password_cb *cd, void *u);
   608 #endif
   609 
   610 #ifndef OPENSSL_SYS_WIN16
   611 IMPORT_C int	PEM_read(FILE *fp, char **name, char **header,
   612 		unsigned char **data,long *len);
   613 IMPORT_C int	PEM_write(FILE *fp,char *name,char *hdr,unsigned char *data,long len);
   614 IMPORT_C void *  PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x,
   615 		      pem_password_cb *cb, void *u);
   616 IMPORT_C int	PEM_ASN1_write(i2d_of_void *i2d,const char *name,FILE *fp,
   617 		       char *x,const EVP_CIPHER *enc,unsigned char *kstr,
   618 		       int klen,pem_password_cb *callback, void *u);
   619 IMPORT_C STACK_OF(X509_INFO) *	PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk,
   620 	pem_password_cb *cb, void *u);
   621 #endif
   622 
   623 IMPORT_C int	PEM_SealInit(PEM_ENCODE_SEAL_CTX *ctx, EVP_CIPHER *type,
   624 		EVP_MD *md_type, unsigned char **ek, int *ekl,
   625 		unsigned char *iv, EVP_PKEY **pubk, int npubk);
   626 IMPORT_C void	PEM_SealUpdate(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *out, int *outl,
   627 		unsigned char *in, int inl);
   628 IMPORT_C int	PEM_SealFinal(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *sig,int *sigl,
   629 		unsigned char *out, int *outl, EVP_PKEY *priv);
   630 
   631 IMPORT_C void    PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type);
   632 IMPORT_C void    PEM_SignUpdate(EVP_MD_CTX *ctx,unsigned char *d,unsigned int cnt);
   633 IMPORT_C int	PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
   634 		unsigned int *siglen, EVP_PKEY *pkey);
   635 
   636 IMPORT_C int	PEM_def_callback(char *buf, int num, int w, void *key);
   637 IMPORT_C void	PEM_proc_type(char *buf, int type);
   638 IMPORT_C void	PEM_dek_info(char *buf, const char *type, int len, char *str);
   639 
   640 #ifndef SSLEAY_MACROS
   641 
   642 #include <openssl/symhacks.h>
   643 
   644 DECLARE_PEM_rw(X509, X509)
   645 
   646 DECLARE_PEM_rw(X509_AUX, X509)
   647 
   648 DECLARE_PEM_rw(X509_CERT_PAIR, X509_CERT_PAIR)
   649 
   650 DECLARE_PEM_rw(X509_REQ, X509_REQ)
   651 DECLARE_PEM_write(X509_REQ_NEW, X509_REQ)
   652 
   653 DECLARE_PEM_rw(X509_CRL, X509_CRL)
   654 
   655 DECLARE_PEM_rw(PKCS7, PKCS7)
   656 
   657 DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE)
   658 
   659 DECLARE_PEM_rw(PKCS8, X509_SIG)
   660 
   661 DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO)
   662 
   663 #ifndef OPENSSL_NO_RSA
   664 
   665 DECLARE_PEM_rw_cb(RSAPrivateKey, RSA)
   666 
   667 DECLARE_PEM_rw_const(RSAPublicKey, RSA)
   668 DECLARE_PEM_rw(RSA_PUBKEY, RSA)
   669 
   670 #endif
   671 
   672 #ifndef OPENSSL_NO_DSA
   673 
   674 DECLARE_PEM_rw_cb(DSAPrivateKey, DSA)
   675 
   676 DECLARE_PEM_rw(DSA_PUBKEY, DSA)
   677 
   678 DECLARE_PEM_rw_const(DSAparams, DSA)
   679 
   680 #endif
   681 
   682 #ifndef OPENSSL_NO_EC
   683 DECLARE_PEM_rw_const(ECPKParameters, EC_GROUP)
   684 DECLARE_PEM_rw_cb(ECPrivateKey, EC_KEY)
   685 DECLARE_PEM_rw(EC_PUBKEY, EC_KEY)
   686 #endif
   687 
   688 #ifndef OPENSSL_NO_DH
   689 
   690 DECLARE_PEM_rw_const(DHparams, DH)
   691 
   692 #endif
   693 
   694 DECLARE_PEM_rw_cb(PrivateKey, EVP_PKEY)
   695 
   696 DECLARE_PEM_rw(PUBKEY, EVP_PKEY)
   697 
   698 IMPORT_C int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid,
   699 				  char *kstr, int klen,
   700 				  pem_password_cb *cb, void *u);
   701 IMPORT_C int PEM_write_bio_PKCS8PrivateKey(BIO *, EVP_PKEY *, const EVP_CIPHER *,
   702                                   char *, int, pem_password_cb *, void *);
   703 IMPORT_C int i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
   704 				  char *kstr, int klen,
   705 				  pem_password_cb *cb, void *u);
   706 IMPORT_C int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid,
   707 				  char *kstr, int klen,
   708 				  pem_password_cb *cb, void *u);
   709 IMPORT_C EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u);
   710 
   711 IMPORT_C int i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
   712 				  char *kstr, int klen,
   713 				  pem_password_cb *cb, void *u);
   714 IMPORT_C int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid,
   715 				  char *kstr, int klen,
   716 				  pem_password_cb *cb, void *u);
   717 IMPORT_C int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid,
   718 				  char *kstr, int klen,
   719 				  pem_password_cb *cb, void *u);
   720 
   721 IMPORT_C EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, void *u);
   722 
   723 IMPORT_C int PEM_write_PKCS8PrivateKey(FILE *fp,EVP_PKEY *x,const EVP_CIPHER *enc,
   724 			      char *kstr,int klen, pem_password_cb *cd, void *u);
   725 
   726 #endif /* SSLEAY_MACROS */
   727 
   728 
   729 /* BEGIN ERROR CODES */
   730 /* The following lines are auto generated by the script mkerr.pl. Any changes
   731  * made after this point may be overwritten when the script is next run.
   732  */
   733 IMPORT_C void ERR_load_PEM_strings(void);
   734 
   735 /* Error codes for the PEM functions. */
   736 
   737 /* Function codes. */
   738 #define PEM_F_D2I_PKCS8PRIVATEKEY_BIO			 120
   739 #define PEM_F_D2I_PKCS8PRIVATEKEY_FP			 121
   740 #define PEM_F_DO_PK8PKEY				 126
   741 #define PEM_F_DO_PK8PKEY_FP				 125
   742 #define PEM_F_LOAD_IV					 101
   743 #define PEM_F_PEM_ASN1_READ				 102
   744 #define PEM_F_PEM_ASN1_READ_BIO				 103
   745 #define PEM_F_PEM_ASN1_WRITE				 104
   746 #define PEM_F_PEM_ASN1_WRITE_BIO			 105
   747 #define PEM_F_PEM_DEF_CALLBACK				 100
   748 #define PEM_F_PEM_DO_HEADER				 106
   749 #define PEM_F_PEM_F_PEM_WRITE_PKCS8PRIVATEKEY		 118
   750 #define PEM_F_PEM_GET_EVP_CIPHER_INFO			 107
   751 #define PEM_F_PEM_PK8PKEY				 119
   752 #define PEM_F_PEM_READ					 108
   753 #define PEM_F_PEM_READ_BIO				 109
   754 #define PEM_F_PEM_READ_BIO_PRIVATEKEY			 123
   755 #define PEM_F_PEM_READ_PRIVATEKEY			 124
   756 #define PEM_F_PEM_SEALFINAL				 110
   757 #define PEM_F_PEM_SEALINIT				 111
   758 #define PEM_F_PEM_SIGNFINAL				 112
   759 #define PEM_F_PEM_WRITE					 113
   760 #define PEM_F_PEM_WRITE_BIO				 114
   761 #define PEM_F_PEM_X509_INFO_READ			 115
   762 #define PEM_F_PEM_X509_INFO_READ_BIO			 116
   763 #define PEM_F_PEM_X509_INFO_WRITE_BIO			 117
   764 
   765 /* Reason codes. */
   766 #define PEM_R_BAD_BASE64_DECODE				 100
   767 #define PEM_R_BAD_DECRYPT				 101
   768 #define PEM_R_BAD_END_LINE				 102
   769 #define PEM_R_BAD_IV_CHARS				 103
   770 #define PEM_R_BAD_PASSWORD_READ				 104
   771 #define PEM_R_ERROR_CONVERTING_PRIVATE_KEY		 115
   772 #define PEM_R_NOT_DEK_INFO				 105
   773 #define PEM_R_NOT_ENCRYPTED				 106
   774 #define PEM_R_NOT_PROC_TYPE				 107
   775 #define PEM_R_NO_START_LINE				 108
   776 #define PEM_R_PROBLEMS_GETTING_PASSWORD			 109
   777 #define PEM_R_PUBLIC_KEY_NO_RSA				 110
   778 #define PEM_R_READ_KEY					 111
   779 #define PEM_R_SHORT_HEADER				 112
   780 #define PEM_R_UNSUPPORTED_CIPHER			 113
   781 #define PEM_R_UNSUPPORTED_ENCRYPTION			 114
   782 
   783 #ifdef  __cplusplus
   784 }
   785 #endif
   786 #endif