EESAST
/
THUAI6
Not watched
1
0
Fork 0
Code
Releases 3 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 0572c63a90
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0572c63a90'
${ noResults }
THUAI6/CAPI/cpp/grpc/include/openssl/pem.h

467 lines
23 kB
Raw Blame History 

  1. /*

  2.  * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.

  3.  *

  4.  * Licensed under the Apache License 2.0 (the "License").  You may not use

  5.  * this file except in compliance with the License.  You can obtain a copy

  6.  * in the file LICENSE in the source distribution or at

  7.  * https://www.openssl.org/source/license.html

  8.  */

  9. 

  10. #ifndef OPENSSL_PEM_H

  11. #define OPENSSL_PEM_H

  12. #pragma once

  13. 

  14. #include <openssl/macros.h>

  15. #ifndef OPENSSL_NO_DEPRECATED_3_0

  16. #define HEADER_PEM_H

  17. #endif

  18. 

  19. #include <openssl/e_os2.h>

  20. #include <openssl/bio.h>

  21. #include <openssl/safestack.h>

  22. #include <openssl/evp.h>

  23. #include <openssl/x509.h>

  24. #include <openssl/pemerr.h>

  25. 

  26. #ifdef __cplusplus

  27. extern "C"

  28. {

  29. #endif

  30. 

  31. #define PEM_BUFSIZE 1024

  32. 

  33. #define PEM_STRING_X509_OLD "X509 CERTIFICATE"

  34. #define PEM_STRING_X509 "CERTIFICATE"

  35. #define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE"

  36. #define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST"

  37. #define PEM_STRING_X509_REQ "CERTIFICATE REQUEST"

  38. #define PEM_STRING_X509_CRL "X509 CRL"

  39. #define PEM_STRING_EVP_PKEY "ANY PRIVATE KEY"

  40. #define PEM_STRING_PUBLIC "PUBLIC KEY"

  41. #define PEM_STRING_RSA "RSA PRIVATE KEY"

  42. #define PEM_STRING_RSA_PUBLIC "RSA PUBLIC KEY"

  43. #define PEM_STRING_DSA "DSA PRIVATE KEY"

  44. #define PEM_STRING_DSA_PUBLIC "DSA PUBLIC KEY"

  45. #define PEM_STRING_PKCS7 "PKCS7"

  46. #define PEM_STRING_PKCS7_SIGNED "PKCS #7 SIGNED DATA"

  47. #define PEM_STRING_PKCS8 "ENCRYPTED PRIVATE KEY"

  48. #define PEM_STRING_PKCS8INF "PRIVATE KEY"

  49. #define PEM_STRING_DHPARAMS "DH PARAMETERS"

  50. #define PEM_STRING_DHXPARAMS "X9.42 DH PARAMETERS"

  51. #define PEM_STRING_SSL_SESSION "SSL SESSION PARAMETERS"

  52. #define PEM_STRING_DSAPARAMS "DSA PARAMETERS"

  53. #define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY"

  54. #define PEM_STRING_ECPARAMETERS "EC PARAMETERS"

  55. #define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY"

  56. #define PEM_STRING_PARAMETERS "PARAMETERS"

  57. #define PEM_STRING_CMS "CMS"

  58. 

  59. #define PEM_TYPE_ENCRYPTED 10

  60. #define PEM_TYPE_MIC_ONLY 20

  61. #define PEM_TYPE_MIC_CLEAR 30

  62. #define PEM_TYPE_CLEAR 40

  63. 

  64.     /*

  65.      * These macros make the PEM_read/PEM_write functions easier to maintain and

  66.      * write. Now they are all implemented with either: IMPLEMENT_PEM_rw(...) or

  67.      * IMPLEMENT_PEM_rw_cb(...)

  68.      */

  69. 

  70. #define PEM_read_cb_fnsig(name, type, INTYPE, readname) \

  71.     type* PEM_##readname##_##name(INTYPE* out, type** x, pem_password_cb* cb, void* u)

  72. #define PEM_read_cb_ex_fnsig(name, type, INTYPE, readname) \

  73.     type* PEM_##readname##_##name##_ex(INTYPE* out, type** x, pem_password_cb* cb, void* u, OSSL_LIB_CTX* libctx, const char* propq)

  74. 

  75. #define PEM_write_fnsig(name, type, OUTTYPE, writename) \

  76.     int PEM_##writename##_##name(OUTTYPE* out, const type* x)

  77. #define PEM_write_cb_fnsig(name, type, OUTTYPE, writename) \

  78.     int PEM_##writename##_##name(OUTTYPE* out, const type* x, const EVP_CIPHER* enc, const unsigned char* kstr, int klen, pem_password_cb* cb, void* u)

  79. #define PEM_write_ex_fnsig(name, type, OUTTYPE, writename) \

  80.     int PEM_##writename##_##name##_ex(OUTTYPE* out, const type* x, OSSL_LIB_CTX* libctx, const char* propq)

  81. #define PEM_write_cb_ex_fnsig(name, type, OUTTYPE, writename) \

  82.     int PEM_##writename##_##name##_ex(OUTTYPE* out, const type* x, const EVP_CIPHER* enc, const unsigned char* kstr, int klen, pem_password_cb* cb, void* u, OSSL_LIB_CTX* libctx, const char* propq)

  83. 

  84. #ifdef OPENSSL_NO_STDIO

  85. 

  86. #define IMPLEMENT_PEM_read_fp(name, type, str, asn1)  /**/

  87. #define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/

  88. #ifndef OPENSSL_NO_DEPRECATED_3_0

  89. #define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) /**/

  90. #endif

  91. #define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/

  92. #ifndef OPENSSL_NO_DEPRECATED_3_0

  93. #define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) /**/

  94. #endif

  95. #else

  96. 

  97. #define IMPLEMENT_PEM_read_fp(name, type, str, asn1)                               \

  98.     type* PEM_read_##name(FILE* fp, type** x, pem_password_cb* cb, void* u)        \

  99.     {                                                                              \

  100.         return PEM_ASN1_read((d2i_of_void*)d2i_##asn1, str, fp, (void**)x, cb, u); \

  101.     }

  102. 

  103. #define IMPLEMENT_PEM_write_fp(name, type, str, asn1)                                            \

  104.     PEM_write_fnsig(name, type, FILE, write)                                                     \

  105.     {                                                                                            \

  106.         return PEM_ASN1_write((i2d_of_void*)i2d_##asn1, str, out, x, NULL, NULL, 0, NULL, NULL); \

  107.     }

  108. 

  109. #ifndef OPENSSL_NO_DEPRECATED_3_0

  110. #define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \

  111.     IMPLEMENT_PEM_write_fp(name, type, str, asn1)

  112. #endif

  113. 

  114. #define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)                                      \

  115.     PEM_write_cb_fnsig(name, type, FILE, write)                                               \

  116.     {                                                                                         \

  117.         return PEM_ASN1_write((i2d_of_void*)i2d_##asn1, str, out, x, enc, kstr, klen, cb, u); \

  118.     }

  119. 

  120. #ifndef OPENSSL_NO_DEPRECATED_3_0

  121. #define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \

  122.     IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)

  123. #endif

  124. #endif

  125. 

  126. #define IMPLEMENT_PEM_read_bio(name, type, str, asn1)                                  \

  127.     type* PEM_read_bio_##name(BIO* bp, type** x, pem_password_cb* cb, void* u)         \

  128.     {                                                                                  \

  129.         return PEM_ASN1_read_bio((d2i_of_void*)d2i_##asn1, str, bp, (void**)x, cb, u); \

  130.     }

  131. 

  132. #define IMPLEMENT_PEM_write_bio(name, type, str, asn1)                                               \

  133.     PEM_write_fnsig(name, type, BIO, write_bio)                                                      \

  134.     {                                                                                                \

  135.         return PEM_ASN1_write_bio((i2d_of_void*)i2d_##asn1, str, out, x, NULL, NULL, 0, NULL, NULL); \

  136.     }

  137. 

  138. #ifndef OPENSSL_NO_DEPRECATED_3_0

  139. #define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \

  140.     IMPLEMENT_PEM_write_bio(name, type, str, asn1)

  141. #endif

  142. 

  143. #define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1)                                         \

  144.     PEM_write_cb_fnsig(name, type, BIO, write_bio)                                                \

  145.     {                                                                                             \

  146.         return PEM_ASN1_write_bio((i2d_of_void*)i2d_##asn1, str, out, x, enc, kstr, klen, cb, u); \

  147.     }

  148. 

  149. #ifndef OPENSSL_NO_DEPRECATED_3_0

  150. #define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \

  151.     IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1)

  152. #endif

  153. 

  154. #define IMPLEMENT_PEM_write(name, type, str, asn1) \

  155.     IMPLEMENT_PEM_write_bio(name, type, str, asn1) \

  156.         IMPLEMENT_PEM_write_fp(name, type, str, asn1)

  157. 

  158. #ifndef OPENSSL_NO_DEPRECATED_3_0

  159. #define IMPLEMENT_PEM_write_const(name, type, str, asn1) \

  160.     IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \

  161.         IMPLEMENT_PEM_write_fp_const(name, type, str, asn1)

  162. #endif

  163. 

  164. #define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \

  165.     IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \

  166.         IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)

  167. 

  168. #ifndef OPENSSL_NO_DEPRECATED_3_0

  169. #define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \

  170.     IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \

  171.         IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1)

  172. #endif

  173. 

  174. #define IMPLEMENT_PEM_read(name, type, str, asn1) \

  175.     IMPLEMENT_PEM_read_bio(name, type, str, asn1) \

  176.         IMPLEMENT_PEM_read_fp(name, type, str, asn1)

  177. 

  178. #define IMPLEMENT_PEM_rw(name, type, str, asn1) \

  179.     IMPLEMENT_PEM_read(name, type, str, asn1)   \

  180.         IMPLEMENT_PEM_write(name, type, str, asn1)

  181. 

  182. #ifndef OPENSSL_NO_DEPRECATED_3_0

  183. #define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \

  184.     IMPLEMENT_PEM_read(name, type, str, asn1)         \

  185.         IMPLEMENT_PEM_write_const(name, type, str, asn1)

  186. #endif

  187. 

  188. #define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \

  189.     IMPLEMENT_PEM_read(name, type, str, asn1)      \

  190.         IMPLEMENT_PEM_write_cb(name, type, str, asn1)

  191. 

  192. /* These are the same except they are for the declarations */

  193. 

  194. /*

  195.  * The mysterious 'extern' that's passed to some macros is innocuous,

  196.  * and is there to quiet pre-C99 compilers that may complain about empty

  197.  * arguments in macro calls.

  198.  */

  199. #if defined(OPENSSL_NO_STDIO)

  200. 

  201. #define DECLARE_PEM_read_fp_attr(attr, name, type)     /**/

  202. #define DECLARE_PEM_read_fp_ex_attr(attr, name, type)  /**/

  203. #define DECLARE_PEM_write_fp_attr(attr, name, type)    /**/

  204. #define DECLARE_PEM_write_fp_ex_attr(attr, name, type) /**/

  205. #ifndef OPENSSL_NO_DEPRECATED_3_0

  206. #define DECLARE_PEM_write_fp_const_attr(attr, name, type) /**/

  207. #endif

  208. #define DECLARE_PEM_write_cb_fp_attr(attr, name, type)    /**/

  209. #define DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type) /**/

  210. 

  211. #else

  212. 

  213. #define DECLARE_PEM_read_fp_attr(attr, name, type) \

  214.     attr PEM_read_cb_fnsig(name, type, FILE, read);

  215. #define DECLARE_PEM_read_fp_ex_attr(attr, name, type) \

  216.     attr PEM_read_cb_fnsig(name, type, FILE, read);   \

  217.     attr PEM_read_cb_ex_fnsig(name, type, FILE, read);

  218. 

  219. #define DECLARE_PEM_write_fp_attr(attr, name, type) \

  220.     attr PEM_write_fnsig(name, type, FILE, write);

  221. #define DECLARE_PEM_write_fp_ex_attr(attr, name, type) \

  222.     attr PEM_write_fnsig(name, type, FILE, write);     \

  223.     attr PEM_write_ex_fnsig(name, type, FILE, write);

  224. #ifndef OPENSSL_NO_DEPRECATED_3_0

  225. #define DECLARE_PEM_write_fp_const_attr(attr, name, type) \

  226.     attr PEM_write_fnsig(name, type, FILE, write);

  227. #endif

  228. #define DECLARE_PEM_write_cb_fp_attr(attr, name, type) \

  229.     attr PEM_write_cb_fnsig(name, type, FILE, write);

  230. #define DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type) \

  231.     attr PEM_write_cb_fnsig(name, type, FILE, write);     \

  232.     attr PEM_write_cb_ex_fnsig(name, type, FILE, write);

  233. 

  234. #endif

  235. 

  236. #define DECLARE_PEM_read_fp(name, type) \

  237.     DECLARE_PEM_read_fp_attr(extern, name, type)

  238. #define DECLARE_PEM_write_fp(name, type) \

  239.     DECLARE_PEM_write_fp_attr(extern, name, type)

  240. #ifndef OPENSSL_NO_DEPRECATED_3_0

  241. #define DECLARE_PEM_write_fp_const(name, type) \

  242.     DECLARE_PEM_write_fp_const_attr(extern, name, type)

  243. #endif

  244. #define DECLARE_PEM_write_cb_fp(name, type) \

  245.     DECLARE_PEM_write_cb_fp_attr(extern, name, type)

  246. 

  247. #define DECLARE_PEM_read_bio_attr(attr, name, type) \

  248.     attr PEM_read_cb_fnsig(name, type, BIO, read_bio);

  249. #define DECLARE_PEM_read_bio_ex_attr(attr, name, type) \

  250.     attr PEM_read_cb_fnsig(name, type, BIO, read_bio); \

  251.     attr PEM_read_cb_ex_fnsig(name, type, BIO, read_bio);

  252. #define DECLARE_PEM_read_bio(name, type) \

  253.     DECLARE_PEM_read_bio_attr(extern, name, type)

  254. #define DECLARE_PEM_read_bio_ex(name, type) \

  255.     DECLARE_PEM_read_bio_ex_attr(extern, name, type)

  256. 

  257. #define DECLARE_PEM_write_bio_attr(attr, name, type) \

  258.     attr PEM_write_fnsig(name, type, BIO, write_bio);

  259. #define DECLARE_PEM_write_bio_ex_attr(attr, name, type) \

  260.     attr PEM_write_fnsig(name, type, BIO, write_bio);   \

  261.     attr PEM_write_ex_fnsig(name, type, BIO, write_bio);

  262. #define DECLARE_PEM_write_bio(name, type) \

  263.     DECLARE_PEM_write_bio_attr(extern, name, type)

  264. #define DECLARE_PEM_write_bio_ex(name, type) \

  265.     DECLARE_PEM_write_bio_ex_attr(extern, name, type)

  266. 

  267. #ifndef OPENSSL_NO_DEPRECATED_3_0

  268. #define DECLARE_PEM_write_bio_const_attr(attr, name, type) \

  269.     attr PEM_write_fnsig(name, type, BIO, write_bio);

  270. #define DECLARE_PEM_write_bio_const(name, type) \

  271.     DECLARE_PEM_write_bio_const_attr(extern, name, type)

  272. #endif

  273. 

  274. #define DECLARE_PEM_write_cb_bio_attr(attr, name, type) \

  275.     attr PEM_write_cb_fnsig(name, type, BIO, write_bio);

  276. #define DECLARE_PEM_write_cb_bio_ex_attr(attr, name, type) \

  277.     attr PEM_write_cb_fnsig(name, type, BIO, write_bio);   \

  278.     attr PEM_write_cb_ex_fnsig(name, type, BIO, write_bio);

  279. #define DECLARE_PEM_write_cb_bio(name, type) \

  280.     DECLARE_PEM_write_cb_bio_attr(extern, name, type)

  281. #define DECLARE_PEM_write_cb_ex_bio(name, type) \

  282.     DECLARE_PEM_write_cb_bio_ex_attr(extern, name, type)

  283. 

  284. #define DECLARE_PEM_write_attr(attr, name, type) \

  285.     DECLARE_PEM_write_bio_attr(attr, name, type) \

  286.         DECLARE_PEM_write_fp_attr(attr, name, type)

  287. #define DECLARE_PEM_write_ex_attr(attr, name, type) \

  288.     DECLARE_PEM_write_bio_ex_attr(attr, name, type) \

  289.         DECLARE_PEM_write_fp_ex_attr(attr, name, type)

  290. #define DECLARE_PEM_write(name, type) \

  291.     DECLARE_PEM_write_attr(extern, name, type)

  292. #define DECLARE_PEM_write_ex(name, type) \

  293.     DECLARE_PEM_write_ex_attr(extern, name, type)

  294. #ifndef OPENSSL_NO_DEPRECATED_3_0

  295. #define DECLARE_PEM_write_const_attr(attr, name, type) \

  296.     DECLARE_PEM_write_bio_const_attr(attr, name, type) \

  297.         DECLARE_PEM_write_fp_const_attr(attr, name, type)

  298. #define DECLARE_PEM_write_const(name, type) \

  299.     DECLARE_PEM_write_const_attr(extern, name, type)

  300. #endif

  301. #define DECLARE_PEM_write_cb_attr(attr, name, type) \

  302.     DECLARE_PEM_write_cb_bio_attr(attr, name, type) \

  303.         DECLARE_PEM_write_cb_fp_attr(attr, name, type)

  304. #define DECLARE_PEM_write_cb_ex_attr(attr, name, type) \

  305.     DECLARE_PEM_write_cb_bio_ex_attr(attr, name, type) \

  306.         DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type)

  307. #define DECLARE_PEM_write_cb(name, type) \

  308.     DECLARE_PEM_write_cb_attr(extern, name, type)

  309. #define DECLARE_PEM_write_cb_ex(name, type) \

  310.     DECLARE_PEM_write_cb_ex_attr(extern, name, type)

  311. #define DECLARE_PEM_read_attr(attr, name, type) \

  312.     DECLARE_PEM_read_bio_attr(attr, name, type) \

  313.         DECLARE_PEM_read_fp_attr(attr, name, type)

  314. #define DECLARE_PEM_read_ex_attr(attr, name, type) \

  315.     DECLARE_PEM_read_bio_ex_attr(attr, name, type) \

  316.         DECLARE_PEM_read_fp_ex_attr(attr, name, type)

  317. #define DECLARE_PEM_read(name, type) \

  318.     DECLARE_PEM_read_attr(extern, name, type)

  319. #define DECLARE_PEM_read_ex(name, type) \

  320.     DECLARE_PEM_read_ex_attr(extern, name, type)

  321. #define DECLARE_PEM_rw_attr(attr, name, type) \

  322.     DECLARE_PEM_read_attr(attr, name, type)   \

  323.         DECLARE_PEM_write_attr(attr, name, type)

  324. #define DECLARE_PEM_rw_ex_attr(attr, name, type) \

  325.     DECLARE_PEM_read_ex_attr(attr, name, type)   \

  326.         DECLARE_PEM_write_ex_attr(attr, name, type)

  327. #define DECLARE_PEM_rw(name, type) \

  328.     DECLARE_PEM_rw_attr(extern, name, type)

  329. #define DECLARE_PEM_rw_ex(name, type) \

  330.     DECLARE_PEM_rw_ex_attr(extern, name, type)

  331. #ifndef OPENSSL_NO_DEPRECATED_3_0

  332. #define DECLARE_PEM_rw_const_attr(attr, name, type) \

  333.     DECLARE_PEM_read_attr(attr, name, type)         \

  334.         DECLARE_PEM_write_const_attr(attr, name, type)

  335. #define DECLARE_PEM_rw_const(name, type) \

  336.     DECLARE_PEM_rw_const_attr(extern, name, type)

  337. #endif

  338. #define DECLARE_PEM_rw_cb_attr(attr, name, type) \

  339.     DECLARE_PEM_read_attr(attr, name, type)      \

  340.         DECLARE_PEM_write_cb_attr(attr, name, type)

  341. #define DECLARE_PEM_rw_cb_ex_attr(attr, name, type) \

  342.     DECLARE_PEM_read_ex_attr(attr, name, type)      \

  343.         DECLARE_PEM_write_cb_ex_attr(attr, name, type)

  344. #define DECLARE_PEM_rw_cb(name, type) \

  345.     DECLARE_PEM_rw_cb_attr(extern, name, type)

  346. #define DECLARE_PEM_rw_cb_ex(name, type) \

  347.     DECLARE_PEM_rw_cb_ex_attr(extern, name, type)

  348. 

  349.     int PEM_get_EVP_CIPHER_INFO(char* header, EVP_CIPHER_INFO* cipher);

  350.     int PEM_do_header(EVP_CIPHER_INFO* cipher, unsigned char* data, long* len, pem_password_cb* callback, void* u);

  351. 

  352.     int PEM_read_bio(BIO* bp, char** name, char** header, unsigned char** data, long* len);

  353. #define PEM_FLAG_SECURE 0x1

  354. #define PEM_FLAG_EAY_COMPATIBLE 0x2

  355. #define PEM_FLAG_ONLY_B64 0x4

  356.     int PEM_read_bio_ex(BIO* bp, char** name, char** header, unsigned char** data, long* len, unsigned int flags);

  357.     int PEM_bytes_read_bio_secmem(unsigned char** pdata, long* plen, char** pnm, const char* name, BIO* bp, pem_password_cb* cb, void* u);

  358.     int PEM_write_bio(BIO* bp, const char* name, const char* hdr, const unsigned char* data, long len);

  359.     int PEM_bytes_read_bio(unsigned char** pdata, long* plen, char** pnm, const char* name, BIO* bp, pem_password_cb* cb, void* u);

  360.     void* PEM_ASN1_read_bio(d2i_of_void* d2i, const char* name, BIO* bp, void** x, pem_password_cb* cb, void* u);

  361.     int PEM_ASN1_write_bio(i2d_of_void* i2d, const char* name, BIO* bp, const void* x, const EVP_CIPHER* enc, const unsigned char* kstr, int klen, pem_password_cb* cb, void* u);

  362. 

  363.     STACK_OF(X509_INFO) * PEM_X509_INFO_read_bio(BIO* bp, STACK_OF(X509_INFO) * sk, pem_password_cb* cb, void* u);

  364.     STACK_OF(X509_INFO)

  365.     *PEM_X509_INFO_read_bio_ex(BIO* bp, STACK_OF(X509_INFO) * sk, pem_password_cb* cb, void* u, OSSL_LIB_CTX* libctx, const char* propq);

  366. 

  367.     int PEM_X509_INFO_write_bio(BIO* bp, const X509_INFO* xi, EVP_CIPHER* enc, const unsigned char* kstr, int klen, pem_password_cb* cd, void* u);

  368. 

  369. #ifndef OPENSSL_NO_STDIO

  370.     int PEM_read(FILE* fp, char** name, char** header, unsigned char** data, long* len);

  371.     int PEM_write(FILE* fp, const char* name, const char* hdr, const unsigned char* data, long len);

  372.     void* PEM_ASN1_read(d2i_of_void* d2i, const char* name, FILE* fp, void** x, pem_password_cb* cb, void* u);

  373.     int PEM_ASN1_write(i2d_of_void* i2d, const char* name, FILE* fp, const void* x, const EVP_CIPHER* enc, const unsigned char* kstr, int klen, pem_password_cb* callback, void* u);

  374.     STACK_OF(X509_INFO) * PEM_X509_INFO_read(FILE* fp, STACK_OF(X509_INFO) * sk, pem_password_cb* cb, void* u);

  375.     STACK_OF(X509_INFO)

  376.     *PEM_X509_INFO_read_ex(FILE* fp, STACK_OF(X509_INFO) * sk, pem_password_cb* cb, void* u, OSSL_LIB_CTX* libctx, const char* propq);

  377. #endif

  378. 

  379.     int PEM_SignInit(EVP_MD_CTX* ctx, EVP_MD* type);

  380.     int PEM_SignUpdate(EVP_MD_CTX* ctx, const unsigned char* d, unsigned int cnt);

  381.     int PEM_SignFinal(EVP_MD_CTX* ctx, unsigned char* sigret, unsigned int* siglen, EVP_PKEY* pkey);

  382. 

  383.     /* The default pem_password_cb that's used internally */

  384.     int PEM_def_callback(char* buf, int num, int rwflag, void* userdata);

  385.     void PEM_proc_type(char* buf, int type);

  386.     void PEM_dek_info(char* buf, const char* type, int len, const char* str);

  387. 

  388. #include <openssl/symhacks.h>

  389. 

  390.     DECLARE_PEM_rw(X509, X509)

  391.         DECLARE_PEM_rw(X509_AUX, X509)

  392.             DECLARE_PEM_rw(X509_REQ, X509_REQ)

  393.                 DECLARE_PEM_write(X509_REQ_NEW, X509_REQ)

  394.                     DECLARE_PEM_rw(X509_CRL, X509_CRL)

  395.                         DECLARE_PEM_rw(X509_PUBKEY, X509_PUBKEY)

  396.                             DECLARE_PEM_rw(PKCS7, PKCS7)

  397.                                 DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE)

  398.                                     DECLARE_PEM_rw(PKCS8, X509_SIG)

  399.                                         DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO)

  400. #ifndef OPENSSL_NO_DEPRECATED_3_0

  401.                                             DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, RSAPrivateKey, RSA)

  402.                                                 DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, RSAPublicKey, RSA)

  403.                                                     DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, RSA_PUBKEY, RSA)

  404. #endif

  405. #ifndef OPENSSL_NO_DEPRECATED_3_0

  406. #ifndef OPENSSL_NO_DSA

  407.                                                         DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, DSAPrivateKey, DSA)

  408.                                                             DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DSA_PUBKEY, DSA)

  409.                                                                 DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DSAparams, DSA)

  410. #endif

  411. #endif

  412. 

  413. #ifndef OPENSSL_NO_DEPRECATED_3_0

  414. #ifndef OPENSSL_NO_EC

  415.                                                                     DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, ECPKParameters, EC_GROUP)

  416.                                                                         DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, ECPrivateKey, EC_KEY)

  417.                                                                             DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, EC_PUBKEY, EC_KEY)

  418. #endif

  419. #endif

  420. 

  421. #ifndef OPENSSL_NO_DH

  422. #ifndef OPENSSL_NO_DEPRECATED_3_0

  423.                                                                                 DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DHparams, DH)

  424.                                                                                     DECLARE_PEM_write_attr(OSSL_DEPRECATEDIN_3_0, DHxparams, DH)

  425. #endif

  426. #endif

  427.                                                                                         DECLARE_PEM_rw_cb_ex(PrivateKey, EVP_PKEY)

  428.                                                                                             DECLARE_PEM_rw_ex(PUBKEY, EVP_PKEY)

  429. 

  430.                                                                                                 int PEM_write_bio_PrivateKey_traditional(BIO* bp, const EVP_PKEY* x, const EVP_CIPHER* enc, const unsigned char* kstr, int klen, pem_password_cb* cb, void* u);

  431. 

  432.     /* Why do these take a signed char *kstr? */

  433.     int PEM_write_bio_PKCS8PrivateKey_nid(BIO* bp, const EVP_PKEY* x, int nid, const char* kstr, int klen, pem_password_cb* cb, void* u);

  434.     int PEM_write_bio_PKCS8PrivateKey(BIO*, const EVP_PKEY*, const EVP_CIPHER*, const char* kstr, int klen, pem_password_cb* cb, void* u);

  435.     int i2d_PKCS8PrivateKey_bio(BIO* bp, const EVP_PKEY* x, const EVP_CIPHER* enc, const char* kstr, int klen, pem_password_cb* cb, void* u);

  436.     int i2d_PKCS8PrivateKey_nid_bio(BIO* bp, const EVP_PKEY* x, int nid, const char* kstr, int klen, pem_password_cb* cb, void* u);

  437.     EVP_PKEY* d2i_PKCS8PrivateKey_bio(BIO* bp, EVP_PKEY** x, pem_password_cb* cb, void* u);

  438. 

  439. #ifndef OPENSSL_NO_STDIO

  440.     int i2d_PKCS8PrivateKey_fp(FILE* fp, const EVP_PKEY* x, const EVP_CIPHER* enc, const char* kstr, int klen, pem_password_cb* cb, void* u);

  441.     int i2d_PKCS8PrivateKey_nid_fp(FILE* fp, const EVP_PKEY* x, int nid, const char* kstr, int klen, pem_password_cb* cb, void* u);

  442.     int PEM_write_PKCS8PrivateKey_nid(FILE* fp, const EVP_PKEY* x, int nid, const char* kstr, int klen, pem_password_cb* cb, void* u);

  443. 

  444.     EVP_PKEY* d2i_PKCS8PrivateKey_fp(FILE* fp, EVP_PKEY** x, pem_password_cb* cb, void* u);

  445. 

  446.     int PEM_write_PKCS8PrivateKey(FILE* fp, const EVP_PKEY* x, const EVP_CIPHER* enc, const char* kstr, int klen, pem_password_cb* cd, void* u);

  447. #endif

  448.     EVP_PKEY* PEM_read_bio_Parameters_ex(BIO* bp, EVP_PKEY** x, OSSL_LIB_CTX* libctx, const char* propq);

  449.     EVP_PKEY* PEM_read_bio_Parameters(BIO* bp, EVP_PKEY** x);

  450.     int PEM_write_bio_Parameters(BIO* bp, const EVP_PKEY* x);

  451. 

  452.     EVP_PKEY* b2i_PrivateKey(const unsigned char** in, long length);

  453.     EVP_PKEY* b2i_PublicKey(const unsigned char** in, long length);

  454.     EVP_PKEY* b2i_PrivateKey_bio(BIO* in);

  455.     EVP_PKEY* b2i_PublicKey_bio(BIO* in);

  456.     int i2b_PrivateKey_bio(BIO* out, const EVP_PKEY* pk);

  457.     int i2b_PublicKey_bio(BIO* out, const EVP_PKEY* pk);

  458.     EVP_PKEY* b2i_PVK_bio(BIO* in, pem_password_cb* cb, void* u);

  459.     EVP_PKEY* b2i_PVK_bio_ex(BIO* in, pem_password_cb* cb, void* u, OSSL_LIB_CTX* libctx, const char* propq);

  460.     int i2b_PVK_bio(BIO* out, const EVP_PKEY* pk, int enclevel, pem_password_cb* cb, void* u);

  461.     int i2b_PVK_bio_ex(BIO* out, const EVP_PKEY* pk, int enclevel, pem_password_cb* cb, void* u, OSSL_LIB_CTX* libctx, const char* propq);

  462. 

  463. #ifdef __cplusplus

  464. }

  465. #endif

  466. #endif