Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-09-27 09:19:56 

0001 /*
0002  * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
0003  *
0004  * Licensed under the Apache License 2.0 (the "License").  You may not use
0005  * this file except in compliance with the License.  You can obtain a copy
0006  * in the file LICENSE in the source distribution or at
0007  * https://www.openssl.org/source/license.html
0008  */
0009 
0010 #ifndef OPENSSL_PEM_H
0011 #define OPENSSL_PEM_H
0012 #pragma once
0013 
0014 #include <openssl/macros.h>
0015 #ifndef OPENSSL_NO_DEPRECATED_3_0
0016 #define HEADER_PEM_H
0017 #endif
0018 
0019 #include <openssl/e_os2.h>
0020 #include <openssl/bio.h>
0021 #include <openssl/safestack.h>
0022 #include <openssl/evp.h>
0023 #include <openssl/x509.h>
0024 #include <openssl/pemerr.h>
0025 #ifndef OPENSSL_NO_STDIO
0026 #include <stdio.h>
0027 #endif
0028 
0029 #ifdef __cplusplus
0030 extern "C" {
0031 #endif
0032 
0033 #define PEM_BUFSIZE 1024
0034 
0035 #define PEM_STRING_X509_OLD "X509 CERTIFICATE"
0036 #define PEM_STRING_X509 "CERTIFICATE"
0037 #define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE"
0038 #define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST"
0039 #define PEM_STRING_X509_REQ "CERTIFICATE REQUEST"
0040 #define PEM_STRING_X509_CRL "X509 CRL"
0041 #define PEM_STRING_EVP_PKEY "ANY PRIVATE KEY"
0042 #define PEM_STRING_PUBLIC "PUBLIC KEY"
0043 #define PEM_STRING_RSA "RSA PRIVATE KEY"
0044 #define PEM_STRING_RSA_PUBLIC "RSA PUBLIC KEY"
0045 #define PEM_STRING_DSA "DSA PRIVATE KEY"
0046 #define PEM_STRING_DSA_PUBLIC "DSA PUBLIC KEY"
0047 #define PEM_STRING_PKCS7 "PKCS7"
0048 #define PEM_STRING_PKCS7_SIGNED "PKCS #7 SIGNED DATA"
0049 #define PEM_STRING_PKCS8 "ENCRYPTED PRIVATE KEY"
0050 #define PEM_STRING_PKCS8INF "PRIVATE KEY"
0051 #define PEM_STRING_DHPARAMS "DH PARAMETERS"
0052 #define PEM_STRING_DHXPARAMS "X9.42 DH PARAMETERS"
0053 #define PEM_STRING_SSL_SESSION "SSL SESSION PARAMETERS"
0054 #define PEM_STRING_DSAPARAMS "DSA PARAMETERS"
0055 #define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY"
0056 #define PEM_STRING_ECPARAMETERS "EC PARAMETERS"
0057 #define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY"
0058 #define PEM_STRING_PARAMETERS "PARAMETERS"
0059 #define PEM_STRING_CMS "CMS"
0060 #define PEM_STRING_SM2PRIVATEKEY "SM2 PRIVATE KEY"
0061 #define PEM_STRING_SM2PARAMETERS "SM2 PARAMETERS"
0062 #define PEM_STRING_ACERT "ATTRIBUTE CERTIFICATE"
0063 
0064 #define PEM_TYPE_ENCRYPTED 10
0065 #define PEM_TYPE_MIC_ONLY 20
0066 #define PEM_TYPE_MIC_CLEAR 30
0067 #define PEM_TYPE_CLEAR 40
0068 
0069 /*
0070  * These macros make the PEM_read/PEM_write functions easier to maintain and
0071  * write. Now they are all implemented with either: IMPLEMENT_PEM_rw(...) or
0072  * IMPLEMENT_PEM_rw_cb(...)
0073  */
0074 
0075 #define PEM_read_cb_fnsig(name, type, INTYPE, readname)  \
0076     type *PEM_##readname##_##name(INTYPE *out, type **x, \
0077         pem_password_cb *cb, void *u)
0078 #define PEM_read_cb_ex_fnsig(name, type, INTYPE, readname)    \
0079     type *PEM_##readname##_##name##_ex(INTYPE *out, type **x, \
0080         pem_password_cb *cb, void *u,                         \
0081         OSSL_LIB_CTX *libctx,                                 \
0082         const char *propq)
0083 
0084 #define PEM_write_fnsig(name, type, OUTTYPE, writename) \
0085     int PEM_##writename##_##name(OUTTYPE *out, const type *x)
0086 #define PEM_write_cb_fnsig(name, type, OUTTYPE, writename)    \
0087     int PEM_##writename##_##name(OUTTYPE *out, const type *x, \
0088         const EVP_CIPHER *enc,                                \
0089         const unsigned char *kstr, int klen,                  \
0090         pem_password_cb *cb, void *u)
0091 #define PEM_write_ex_fnsig(name, type, OUTTYPE, writename)         \
0092     int PEM_##writename##_##name##_ex(OUTTYPE *out, const type *x, \
0093         OSSL_LIB_CTX *libctx,                                      \
0094         const char *propq)
0095 #define PEM_write_cb_ex_fnsig(name, type, OUTTYPE, writename)      \
0096     int PEM_##writename##_##name##_ex(OUTTYPE *out, const type *x, \
0097         const EVP_CIPHER *enc,                                     \
0098         const unsigned char *kstr, int klen,                       \
0099         pem_password_cb *cb, void *u,                              \
0100         OSSL_LIB_CTX *libctx,                                      \
0101         const char *propq)
0102 
0103 #ifdef OPENSSL_NO_STDIO
0104 
0105 #define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/
0106 #define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/
0107 #ifndef OPENSSL_NO_DEPRECATED_3_0
0108 #define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) /**/
0109 #endif
0110 #define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/
0111 #ifndef OPENSSL_NO_DEPRECATED_3_0
0112 #define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) /**/
0113 #endif
0114 #else
0115 
0116 #define IMPLEMENT_PEM_read_fp(name, type, str, asn1)                        \
0117     type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u) \
0118     {                                                                       \
0119         return PEM_ASN1_read((d2i_of_void *)d2i_##asn1, str, fp,            \
0120             (void **)x, cb, u);                                             \
0121     }
0122 
0123 #define IMPLEMENT_PEM_write_fp(name, type, str, asn1)              \
0124     PEM_write_fnsig(name, type, FILE, write)                       \
0125     {                                                              \
0126         return PEM_ASN1_write((i2d_of_void *)i2d_##asn1, str, out, \
0127             x, NULL, NULL, 0, NULL, NULL);                         \
0128     }
0129 
0130 #ifndef OPENSSL_NO_DEPRECATED_3_0
0131 #define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \
0132     IMPLEMENT_PEM_write_fp(name, type, str, asn1)
0133 #endif
0134 
0135 #define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)           \
0136     PEM_write_cb_fnsig(name, type, FILE, write)                    \
0137     {                                                              \
0138         return PEM_ASN1_write((i2d_of_void *)i2d_##asn1, str, out, \
0139             x, enc, kstr, klen, cb, u);                            \
0140     }
0141 
0142 #ifndef OPENSSL_NO_DEPRECATED_3_0
0143 #define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \
0144     IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)
0145 #endif
0146 #endif
0147 
0148 #define IMPLEMENT_PEM_read_bio(name, type, str, asn1)                \
0149     type *PEM_read_bio_##name(BIO *bp, type **x,                     \
0150         pem_password_cb *cb, void *u)                                \
0151     {                                                                \
0152         return PEM_ASN1_read_bio((d2i_of_void *)d2i_##asn1, str, bp, \
0153             (void **)x, cb, u);                                      \
0154     }
0155 
0156 #define IMPLEMENT_PEM_write_bio(name, type, str, asn1)                 \
0157     PEM_write_fnsig(name, type, BIO, write_bio)                        \
0158     {                                                                  \
0159         return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1, str, out, \
0160             x, NULL, NULL, 0, NULL, NULL);                             \
0161     }
0162 
0163 #ifndef OPENSSL_NO_DEPRECATED_3_0
0164 #define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \
0165     IMPLEMENT_PEM_write_bio(name, type, str, asn1)
0166 #endif
0167 
0168 #define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1)              \
0169     PEM_write_cb_fnsig(name, type, BIO, write_bio)                     \
0170     {                                                                  \
0171         return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1, str, out, \
0172             x, enc, kstr, klen, cb, u);                                \
0173     }
0174 
0175 #ifndef OPENSSL_NO_DEPRECATED_3_0
0176 #define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \
0177     IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1)
0178 #endif
0179 
0180 #define IMPLEMENT_PEM_write(name, type, str, asn1) \
0181     IMPLEMENT_PEM_write_bio(name, type, str, asn1) \
0182     IMPLEMENT_PEM_write_fp(name, type, str, asn1)
0183 
0184 #ifndef OPENSSL_NO_DEPRECATED_3_0
0185 #define IMPLEMENT_PEM_write_const(name, type, str, asn1) \
0186     IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \
0187     IMPLEMENT_PEM_write_fp_const(name, type, str, asn1)
0188 #endif
0189 
0190 #define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \
0191     IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \
0192     IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)
0193 
0194 #ifndef OPENSSL_NO_DEPRECATED_3_0
0195 #define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \
0196     IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \
0197     IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1)
0198 #endif
0199 
0200 #define IMPLEMENT_PEM_read(name, type, str, asn1) \
0201     IMPLEMENT_PEM_read_bio(name, type, str, asn1) \
0202     IMPLEMENT_PEM_read_fp(name, type, str, asn1)
0203 
0204 #define IMPLEMENT_PEM_rw(name, type, str, asn1) \
0205     IMPLEMENT_PEM_read(name, type, str, asn1)   \
0206     IMPLEMENT_PEM_write(name, type, str, asn1)
0207 
0208 #ifndef OPENSSL_NO_DEPRECATED_3_0
0209 #define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \
0210     IMPLEMENT_PEM_read(name, type, str, asn1)         \
0211     IMPLEMENT_PEM_write_const(name, type, str, asn1)
0212 #endif
0213 
0214 #define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \
0215     IMPLEMENT_PEM_read(name, type, str, asn1)      \
0216     IMPLEMENT_PEM_write_cb(name, type, str, asn1)
0217 
0218 /* These are the same except they are for the declarations */
0219 
0220 /*
0221  * The mysterious 'extern' that's passed to some macros is innocuous,
0222  * and is there to quiet pre-C99 compilers that may complain about empty
0223  * arguments in macro calls.
0224  */
0225 #if defined(OPENSSL_NO_STDIO)
0226 
0227 #define DECLARE_PEM_read_fp_attr(attr, name, type) /**/
0228 #define DECLARE_PEM_read_fp_ex_attr(attr, name, type) /**/
0229 #define DECLARE_PEM_write_fp_attr(attr, name, type) /**/
0230 #define DECLARE_PEM_write_fp_ex_attr(attr, name, type) /**/
0231 #ifndef OPENSSL_NO_DEPRECATED_3_0
0232 #define DECLARE_PEM_write_fp_const_attr(attr, name, type) /**/
0233 #endif
0234 #define DECLARE_PEM_write_cb_fp_attr(attr, name, type) /**/
0235 #define DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type) /**/
0236 
0237 #else
0238 
0239 #define DECLARE_PEM_read_fp_attr(attr, name, type) \
0240     attr PEM_read_cb_fnsig(name, type, FILE, read);
0241 #define DECLARE_PEM_read_fp_ex_attr(attr, name, type) \
0242     attr PEM_read_cb_fnsig(name, type, FILE, read);   \
0243     attr PEM_read_cb_ex_fnsig(name, type, FILE, read);
0244 
0245 #define DECLARE_PEM_write_fp_attr(attr, name, type) \
0246     attr PEM_write_fnsig(name, type, FILE, write);
0247 #define DECLARE_PEM_write_fp_ex_attr(attr, name, type) \
0248     attr PEM_write_fnsig(name, type, FILE, write);     \
0249     attr PEM_write_ex_fnsig(name, type, FILE, write);
0250 #ifndef OPENSSL_NO_DEPRECATED_3_0
0251 #define DECLARE_PEM_write_fp_const_attr(attr, name, type) \
0252     attr PEM_write_fnsig(name, type, FILE, write);
0253 #endif
0254 #define DECLARE_PEM_write_cb_fp_attr(attr, name, type) \
0255     attr PEM_write_cb_fnsig(name, type, FILE, write);
0256 #define DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type) \
0257     attr PEM_write_cb_fnsig(name, type, FILE, write);     \
0258     attr PEM_write_cb_ex_fnsig(name, type, FILE, write);
0259 
0260 #endif
0261 
0262 #define DECLARE_PEM_read_fp(name, type) \
0263     DECLARE_PEM_read_fp_attr(extern, name, type)
0264 #define DECLARE_PEM_write_fp(name, type) \
0265     DECLARE_PEM_write_fp_attr(extern, name, type)
0266 #ifndef OPENSSL_NO_DEPRECATED_3_0
0267 #define DECLARE_PEM_write_fp_const(name, type) \
0268     DECLARE_PEM_write_fp_const_attr(extern, name, type)
0269 #endif
0270 #define DECLARE_PEM_write_cb_fp(name, type) \
0271     DECLARE_PEM_write_cb_fp_attr(extern, name, type)
0272 
0273 #define DECLARE_PEM_read_bio_attr(attr, name, type) \
0274     attr PEM_read_cb_fnsig(name, type, BIO, read_bio);
0275 #define DECLARE_PEM_read_bio_ex_attr(attr, name, type) \
0276     attr PEM_read_cb_fnsig(name, type, BIO, read_bio); \
0277     attr PEM_read_cb_ex_fnsig(name, type, BIO, read_bio);
0278 #define DECLARE_PEM_read_bio(name, type) \
0279     DECLARE_PEM_read_bio_attr(extern, name, type)
0280 #define DECLARE_PEM_read_bio_ex(name, type) \
0281     DECLARE_PEM_read_bio_ex_attr(extern, name, type)
0282 
0283 #define DECLARE_PEM_write_bio_attr(attr, name, type) \
0284     attr PEM_write_fnsig(name, type, BIO, write_bio);
0285 #define DECLARE_PEM_write_bio_ex_attr(attr, name, type) \
0286     attr PEM_write_fnsig(name, type, BIO, write_bio);   \
0287     attr PEM_write_ex_fnsig(name, type, BIO, write_bio);
0288 #define DECLARE_PEM_write_bio(name, type) \
0289     DECLARE_PEM_write_bio_attr(extern, name, type)
0290 #define DECLARE_PEM_write_bio_ex(name, type) \
0291     DECLARE_PEM_write_bio_ex_attr(extern, name, type)
0292 
0293 #ifndef OPENSSL_NO_DEPRECATED_3_0
0294 #define DECLARE_PEM_write_bio_const_attr(attr, name, type) \
0295     attr PEM_write_fnsig(name, type, BIO, write_bio);
0296 #define DECLARE_PEM_write_bio_const(name, type) \
0297     DECLARE_PEM_write_bio_const_attr(extern, name, type)
0298 #endif
0299 
0300 #define DECLARE_PEM_write_cb_bio_attr(attr, name, type) \
0301     attr PEM_write_cb_fnsig(name, type, BIO, write_bio);
0302 #define DECLARE_PEM_write_cb_bio_ex_attr(attr, name, type) \
0303     attr PEM_write_cb_fnsig(name, type, BIO, write_bio);   \
0304     attr PEM_write_cb_ex_fnsig(name, type, BIO, write_bio);
0305 #define DECLARE_PEM_write_cb_bio(name, type) \
0306     DECLARE_PEM_write_cb_bio_attr(extern, name, type)
0307 #define DECLARE_PEM_write_cb_ex_bio(name, type) \
0308     DECLARE_PEM_write_cb_bio_ex_attr(extern, name, type)
0309 
0310 #define DECLARE_PEM_write_attr(attr, name, type) \
0311     DECLARE_PEM_write_bio_attr(attr, name, type) \
0312     DECLARE_PEM_write_fp_attr(attr, name, type)
0313 #define DECLARE_PEM_write_ex_attr(attr, name, type) \
0314     DECLARE_PEM_write_bio_ex_attr(attr, name, type) \
0315     DECLARE_PEM_write_fp_ex_attr(attr, name, type)
0316 #define DECLARE_PEM_write(name, type) \
0317     DECLARE_PEM_write_attr(extern, name, type)
0318 #define DECLARE_PEM_write_ex(name, type) \
0319     DECLARE_PEM_write_ex_attr(extern, name, type)
0320 #ifndef OPENSSL_NO_DEPRECATED_3_0
0321 #define DECLARE_PEM_write_const_attr(attr, name, type) \
0322     DECLARE_PEM_write_bio_const_attr(attr, name, type) \
0323     DECLARE_PEM_write_fp_const_attr(attr, name, type)
0324 #define DECLARE_PEM_write_const(name, type) \
0325     DECLARE_PEM_write_const_attr(extern, name, type)
0326 #endif
0327 #define DECLARE_PEM_write_cb_attr(attr, name, type) \
0328     DECLARE_PEM_write_cb_bio_attr(attr, name, type) \
0329     DECLARE_PEM_write_cb_fp_attr(attr, name, type)
0330 #define DECLARE_PEM_write_cb_ex_attr(attr, name, type) \
0331     DECLARE_PEM_write_cb_bio_ex_attr(attr, name, type) \
0332     DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type)
0333 #define DECLARE_PEM_write_cb(name, type) \
0334     DECLARE_PEM_write_cb_attr(extern, name, type)
0335 #define DECLARE_PEM_write_cb_ex(name, type) \
0336     DECLARE_PEM_write_cb_ex_attr(extern, name, type)
0337 #define DECLARE_PEM_read_attr(attr, name, type) \
0338     DECLARE_PEM_read_bio_attr(attr, name, type) \
0339     DECLARE_PEM_read_fp_attr(attr, name, type)
0340 #define DECLARE_PEM_read_ex_attr(attr, name, type) \
0341     DECLARE_PEM_read_bio_ex_attr(attr, name, type) \
0342     DECLARE_PEM_read_fp_ex_attr(attr, name, type)
0343 #define DECLARE_PEM_read(name, type) \
0344     DECLARE_PEM_read_attr(extern, name, type)
0345 #define DECLARE_PEM_read_ex(name, type) \
0346     DECLARE_PEM_read_ex_attr(extern, name, type)
0347 #define DECLARE_PEM_rw_attr(attr, name, type) \
0348     DECLARE_PEM_read_attr(attr, name, type)   \
0349     DECLARE_PEM_write_attr(attr, name, type)
0350 #define DECLARE_PEM_rw_ex_attr(attr, name, type) \
0351     DECLARE_PEM_read_ex_attr(attr, name, type)   \
0352     DECLARE_PEM_write_ex_attr(attr, name, type)
0353 #define DECLARE_PEM_rw(name, type) \
0354     DECLARE_PEM_rw_attr(extern, name, type)
0355 #define DECLARE_PEM_rw_ex(name, type) \
0356     DECLARE_PEM_rw_ex_attr(extern, name, type)
0357 #ifndef OPENSSL_NO_DEPRECATED_3_0
0358 #define DECLARE_PEM_rw_const_attr(attr, name, type) \
0359     DECLARE_PEM_read_attr(attr, name, type)         \
0360     DECLARE_PEM_write_const_attr(attr, name, type)
0361 #define DECLARE_PEM_rw_const(name, type) \
0362     DECLARE_PEM_rw_const_attr(extern, name, type)
0363 #endif
0364 #define DECLARE_PEM_rw_cb_attr(attr, name, type) \
0365     DECLARE_PEM_read_attr(attr, name, type)      \
0366     DECLARE_PEM_write_cb_attr(attr, name, type)
0367 #define DECLARE_PEM_rw_cb_ex_attr(attr, name, type) \
0368     DECLARE_PEM_read_ex_attr(attr, name, type)      \
0369     DECLARE_PEM_write_cb_ex_attr(attr, name, type)
0370 #define DECLARE_PEM_rw_cb(name, type) \
0371     DECLARE_PEM_rw_cb_attr(extern, name, type)
0372 #define DECLARE_PEM_rw_cb_ex(name, type) \
0373     DECLARE_PEM_rw_cb_ex_attr(extern, name, type)
0374 
0375 int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher);
0376 int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *len,
0377     pem_password_cb *callback, void *u);
0378 
0379 int PEM_read_bio(BIO *bp, char **name, char **header,
0380     unsigned char **data, long *len);
0381 #define PEM_FLAG_SECURE 0x1
0382 #define PEM_FLAG_EAY_COMPATIBLE 0x2
0383 #define PEM_FLAG_ONLY_B64 0x4
0384 int PEM_read_bio_ex(BIO *bp, char **name, char **header,
0385     unsigned char **data, long *len, unsigned int flags);
0386 int PEM_bytes_read_bio_secmem(unsigned char **pdata, long *plen, char **pnm,
0387     const char *name, BIO *bp, pem_password_cb *cb,
0388     void *u);
0389 int PEM_write_bio(BIO *bp, const char *name, const char *hdr,
0390     const unsigned char *data, long len);
0391 int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm,
0392     const char *name, BIO *bp, pem_password_cb *cb,
0393     void *u);
0394 void *PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp, void **x,
0395     pem_password_cb *cb, void *u);
0396 int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp,
0397     const void *x, const EVP_CIPHER *enc,
0398     const unsigned char *kstr, int klen,
0399     pem_password_cb *cb, void *u);
0400 int PEM_ASN1_write_bio_ctx(OSSL_i2d_of_void_ctx *i2d, void *vctx,
0401     const char *name, BIO *bp, const void *x,
0402     const EVP_CIPHER *enc, const unsigned char *kstr,
0403     int klen, pem_password_cb *cb, void *u);
0404 
0405 STACK_OF(X509_INFO) *PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk,
0406     pem_password_cb *cb, void *u);
0407 STACK_OF(X509_INFO)
0408 *PEM_X509_INFO_read_bio_ex(BIO *bp, STACK_OF(X509_INFO) *sk,
0409     pem_password_cb *cb, void *u, OSSL_LIB_CTX *libctx,
0410     const char *propq);
0411 
0412 int PEM_X509_INFO_write_bio(BIO *bp, const X509_INFO *xi, EVP_CIPHER *enc,
0413     const unsigned char *kstr, int klen,
0414     pem_password_cb *cd, void *u);
0415 
0416 #ifndef OPENSSL_NO_STDIO
0417 int PEM_read(FILE *fp, char **name, char **header,
0418     unsigned char **data, long *len);
0419 int PEM_write(FILE *fp, const char *name, const char *hdr,
0420     const unsigned char *data, long len);
0421 void *PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x,
0422     pem_password_cb *cb, void *u);
0423 int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp,
0424     const void *x, const EVP_CIPHER *enc,
0425     const unsigned char *kstr, int klen,
0426     pem_password_cb *callback, void *u);
0427 STACK_OF(X509_INFO) *PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk,
0428     pem_password_cb *cb, void *u);
0429 STACK_OF(X509_INFO)
0430 *PEM_X509_INFO_read_ex(FILE *fp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb,
0431     void *u, OSSL_LIB_CTX *libctx, const char *propq);
0432 #endif
0433 
0434 int PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type);
0435 int PEM_SignUpdate(EVP_MD_CTX *ctx, const unsigned char *d, unsigned int cnt);
0436 int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
0437     unsigned int *siglen, EVP_PKEY *pkey);
0438 
0439 /* The default pem_password_cb that's used internally */
0440 int PEM_def_callback(char *buf, int num, int rwflag, void *userdata);
0441 void PEM_proc_type(char *buf, int type);
0442 void PEM_dek_info(char *buf, const char *type, int len, const char *str);
0443 
0444 #include <openssl/symhacks.h>
0445 
0446 DECLARE_PEM_rw(X509, X509)
0447 DECLARE_PEM_rw(X509_AUX, X509)
0448 DECLARE_PEM_rw(X509_REQ, X509_REQ)
0449 DECLARE_PEM_write(X509_REQ_NEW, X509_REQ)
0450 DECLARE_PEM_rw(X509_CRL, X509_CRL)
0451 DECLARE_PEM_rw(X509_PUBKEY, X509_PUBKEY)
0452 DECLARE_PEM_rw(PKCS7, PKCS7)
0453 DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE)
0454 DECLARE_PEM_rw(PKCS8, X509_SIG)
0455 DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO)
0456 #ifndef OPENSSL_NO_DEPRECATED_3_0
0457 DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, RSAPrivateKey, RSA)
0458 DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, RSAPublicKey, RSA)
0459 DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, RSA_PUBKEY, RSA)
0460 #endif
0461 #ifndef OPENSSL_NO_DEPRECATED_3_0
0462 #ifndef OPENSSL_NO_DSA
0463 DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, DSAPrivateKey, DSA)
0464 DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DSA_PUBKEY, DSA)
0465 DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DSAparams, DSA)
0466 #endif
0467 #endif
0468 
0469 #ifndef OPENSSL_NO_DEPRECATED_3_0
0470 #ifndef OPENSSL_NO_EC
0471 DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, ECPKParameters, EC_GROUP)
0472 DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, ECPrivateKey, EC_KEY)
0473 DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, EC_PUBKEY, EC_KEY)
0474 #endif
0475 #endif
0476 
0477 #ifndef OPENSSL_NO_DH
0478 #ifndef OPENSSL_NO_DEPRECATED_3_0
0479 DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DHparams, DH)
0480 DECLARE_PEM_write_attr(OSSL_DEPRECATEDIN_3_0, DHxparams, DH)
0481 #endif
0482 #endif
0483 DECLARE_PEM_rw_cb_ex(PrivateKey, EVP_PKEY)
0484 DECLARE_PEM_rw_ex(PUBKEY, EVP_PKEY)
0485 
0486 int PEM_write_bio_PrivateKey_traditional(BIO *bp, const EVP_PKEY *x,
0487     const EVP_CIPHER *enc,
0488     const unsigned char *kstr, int klen,
0489     pem_password_cb *cb, void *u);
0490 
0491 /* Why do these take a signed char *kstr? */
0492 int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, const EVP_PKEY *x, int nid,
0493     const char *kstr, int klen,
0494     pem_password_cb *cb, void *u);
0495 int PEM_write_bio_PKCS8PrivateKey(BIO *, const EVP_PKEY *, const EVP_CIPHER *,
0496     const char *kstr, int klen,
0497     pem_password_cb *cb, void *u);
0498 int i2d_PKCS8PrivateKey_bio(BIO *bp, const EVP_PKEY *x, const EVP_CIPHER *enc,
0499     const char *kstr, int klen,
0500     pem_password_cb *cb, void *u);
0501 int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, const EVP_PKEY *x, int nid,
0502     const char *kstr, int klen,
0503     pem_password_cb *cb, void *u);
0504 EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb,
0505     void *u);
0506 
0507 #ifndef OPENSSL_NO_STDIO
0508 int i2d_PKCS8PrivateKey_fp(FILE *fp, const EVP_PKEY *x, const EVP_CIPHER *enc,
0509     const char *kstr, int klen,
0510     pem_password_cb *cb, void *u);
0511 int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, const EVP_PKEY *x, int nid,
0512     const char *kstr, int klen,
0513     pem_password_cb *cb, void *u);
0514 int PEM_write_PKCS8PrivateKey_nid(FILE *fp, const EVP_PKEY *x, int nid,
0515     const char *kstr, int klen,
0516     pem_password_cb *cb, void *u);
0517 
0518 EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb,
0519     void *u);
0520 
0521 int PEM_write_PKCS8PrivateKey(FILE *fp, const EVP_PKEY *x, const EVP_CIPHER *enc,
0522     const char *kstr, int klen,
0523     pem_password_cb *cd, void *u);
0524 #endif
0525 EVP_PKEY *PEM_read_bio_Parameters_ex(BIO *bp, EVP_PKEY **x,
0526     OSSL_LIB_CTX *libctx, const char *propq);
0527 EVP_PKEY *PEM_read_bio_Parameters(BIO *bp, EVP_PKEY **x);
0528 int PEM_write_bio_Parameters(BIO *bp, const EVP_PKEY *x);
0529 
0530 EVP_PKEY *b2i_PrivateKey(const unsigned char **in, long length);
0531 EVP_PKEY *b2i_PublicKey(const unsigned char **in, long length);
0532 EVP_PKEY *b2i_PrivateKey_bio(BIO *in);
0533 EVP_PKEY *b2i_PublicKey_bio(BIO *in);
0534 int i2b_PrivateKey_bio(BIO *out, const EVP_PKEY *pk);
0535 int i2b_PublicKey_bio(BIO *out, const EVP_PKEY *pk);
0536 EVP_PKEY *b2i_PVK_bio(BIO *in, pem_password_cb *cb, void *u);
0537 EVP_PKEY *b2i_PVK_bio_ex(BIO *in, pem_password_cb *cb, void *u,
0538     OSSL_LIB_CTX *libctx, const char *propq);
0539 int i2b_PVK_bio(BIO *out, const EVP_PKEY *pk, int enclevel,
0540     pem_password_cb *cb, void *u);
0541 int i2b_PVK_bio_ex(BIO *out, const EVP_PKEY *pk, int enclevel,
0542     pem_password_cb *cb, void *u,
0543     OSSL_LIB_CTX *libctx, const char *propq);
0544 
0545 #ifdef __cplusplus
0546 }
0547 #endif
0548 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!