contrib/openssl/include/openssl/x509.h

   1 /* crypto/x509/x509.h */\r
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)\r
   3  * All rights reserved.\r
   4  *\r
   5  * This package is an SSL implementation written\r
   6  * by Eric Young (eay@cryptsoft.com).\r
   7  * The implementation was written so as to conform with Netscapes SSL.\r
   8  *\r
   9  * This library is free for commercial and non-commercial use as long as\r
  10  * the following conditions are aheared to.  The following conditions\r
  11  * apply to all code found in this distribution, be it the RC4, RSA,\r
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation\r
  13  * included with this distribution is covered by the same copyright terms\r
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).\r
  15  *\r
  16  * Copyright remains Eric Young's, and as such any Copyright notices in\r
  17  * the code are not to be removed.\r
  18  * If this package is used in a product, Eric Young should be given attribution\r
  19  * as the author of the parts of the library used.\r
  20  * This can be in the form of a textual message at program startup or\r
  21  * in documentation (online or textual) provided with the package.\r
  22  *\r
  23  * Redistribution and use in source and binary forms, with or without\r
  24  * modification, are permitted provided that the following conditions\r
  25  * are met:\r
  26  * 1. Redistributions of source code must retain the copyright\r
  27  *    notice, this list of conditions and the following disclaimer.\r
  28  * 2. Redistributions in binary form must reproduce the above copyright\r
  29  *    notice, this list of conditions and the following disclaimer in the\r
  30  *    documentation and/or other materials provided with the distribution.\r
  31  * 3. All advertising materials mentioning features or use of this software\r
  32  *    must display the following acknowledgement:\r
  33  *    "This product includes cryptographic software written by\r
  34  *     Eric Young (eay@cryptsoft.com)"\r
  35  *    The word 'cryptographic' can be left out if the rouines from the library\r
  36  *    being used are not cryptographic related :-).\r
  37  * 4. If you include any Windows specific code (or a derivative thereof) from\r
  38  *    the apps directory (application code) you must include an acknowledgement:\r
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"\r
  40  *\r
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND\r
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\r
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
  51  * SUCH DAMAGE.\r
  52  *\r
  53  * The licence and distribution terms for any publically available version or\r
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be\r
  55  * copied and put under another distribution licence\r
  56  * [including the GNU Public Licence.]\r
  57  */\r
  58 /* ====================================================================\r
  59  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.\r
  60  * ECDH support in OpenSSL originally developed by\r
  61  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.\r
  62  */\r
  63 \r
  64 #ifndef HEADER_X509_H\r
  65 # define HEADER_X509_H\r
  66 \r
  67 # include <openssl/e_os2.h>\r
  68 # include <openssl/symhacks.h>\r
  69 # ifndef OPENSSL_NO_BUFFER\r
  70 #  include <openssl/buffer.h>\r
  71 # endif\r
  72 # ifndef OPENSSL_NO_EVP\r
  73 #  include <openssl/evp.h>\r
  74 # endif\r
  75 # ifndef OPENSSL_NO_BIO\r
  76 #  include <openssl/bio.h>\r
  77 # endif\r
  78 # include <openssl/stack.h>\r
  79 # include <openssl/asn1.h>\r
  80 # include <openssl/safestack.h>\r
  81 \r
  82 # ifndef OPENSSL_NO_EC\r
  83 #  include <openssl/ec.h>\r
  84 # endif\r
  85 \r
  86 # ifndef OPENSSL_NO_ECDSA\r
  87 #  include <openssl/ecdsa.h>\r
  88 # endif\r
  89 \r
  90 # ifndef OPENSSL_NO_ECDH\r
  91 #  include <openssl/ecdh.h>\r
  92 # endif\r
  93 \r
  94 # ifndef OPENSSL_NO_DEPRECATED\r
  95 #  ifndef OPENSSL_NO_RSA\r
  96 #   include <openssl/rsa.h>\r
  97 #  endif\r
  98 #  ifndef OPENSSL_NO_DSA\r
  99 #   include <openssl/dsa.h>\r
 100 #  endif\r
 101 #  ifndef OPENSSL_NO_DH\r
 102 #   include <openssl/dh.h>\r
 103 #  endif\r
 104 # endif\r
 105 \r
 106 # ifndef OPENSSL_NO_SHA\r
 107 #  include <openssl/sha.h>\r
 108 # endif\r
 109 # include <openssl/ossl_typ.h>\r
 110 \r
 111 #ifdef  __cplusplus\r
 112 extern "C" {\r
 113 #endif\r
 114 \r
 115 # ifdef OPENSSL_SYS_WIN32\r
 116 /* Under Win32 these are defined in wincrypt.h */\r
 117 #  undef X509_NAME\r
 118 #  undef X509_CERT_PAIR\r
 119 #  undef X509_EXTENSIONS\r
 120 # endif\r
 121 \r
 122 # define X509_FILETYPE_PEM       1\r
 123 # define X509_FILETYPE_ASN1      2\r
 124 # define X509_FILETYPE_DEFAULT   3\r
 125 \r
 126 # define X509v3_KU_DIGITAL_SIGNATURE     0x0080\r
 127 # define X509v3_KU_NON_REPUDIATION       0x0040\r
 128 # define X509v3_KU_KEY_ENCIPHERMENT      0x0020\r
 129 # define X509v3_KU_DATA_ENCIPHERMENT     0x0010\r
 130 # define X509v3_KU_KEY_AGREEMENT         0x0008\r
 131 # define X509v3_KU_KEY_CERT_SIGN         0x0004\r
 132 # define X509v3_KU_CRL_SIGN              0x0002\r
 133 # define X509v3_KU_ENCIPHER_ONLY         0x0001\r
 134 # define X509v3_KU_DECIPHER_ONLY         0x8000\r
 135 # define X509v3_KU_UNDEF                 0xffff\r
 136 \r
 137 typedef struct X509_objects_st {\r
 138     int nid;\r
 139     int (*a2i) (void);\r
 140     int (*i2a) (void);\r
 141 } X509_OBJECTS;\r
 142 \r
 143 struct X509_algor_st {\r
 144     ASN1_OBJECT *algorithm;\r
 145     ASN1_TYPE *parameter;\r
 146 } /* X509_ALGOR */ ;\r
 147 \r
 148 DECLARE_ASN1_SET_OF(X509_ALGOR)\r
 149 \r
 150 typedef STACK_OF(X509_ALGOR) X509_ALGORS;\r
 151 \r
 152 typedef struct X509_val_st {\r
 153     ASN1_TIME *notBefore;\r
 154     ASN1_TIME *notAfter;\r
 155 } X509_VAL;\r
 156 \r
 157 struct X509_pubkey_st {\r
 158     X509_ALGOR *algor;\r
 159     ASN1_BIT_STRING *public_key;\r
 160     EVP_PKEY *pkey;\r
 161 };\r
 162 \r
 163 typedef struct X509_sig_st {\r
 164     X509_ALGOR *algor;\r
 165     ASN1_OCTET_STRING *digest;\r
 166 } X509_SIG;\r
 167 \r
 168 typedef struct X509_name_entry_st {\r
 169     ASN1_OBJECT *object;\r
 170     ASN1_STRING *value;\r
 171     int set;\r
 172     int size;                   /* temp variable */\r
 173 } X509_NAME_ENTRY;\r
 174 \r
 175 DECLARE_STACK_OF(X509_NAME_ENTRY)\r
 176 DECLARE_ASN1_SET_OF(X509_NAME_ENTRY)\r
 177 \r
 178 /* we always keep X509_NAMEs in 2 forms. */\r
 179 struct X509_name_st {\r
 180     STACK_OF(X509_NAME_ENTRY) *entries;\r
 181     int modified;               /* true if 'bytes' needs to be built */\r
 182 # ifndef OPENSSL_NO_BUFFER\r
 183     BUF_MEM *bytes;\r
 184 # else\r
 185     char *bytes;\r
 186 # endif\r
 187 /*      unsigned long hash; Keep the hash around for lookups */\r
 188     unsigned char *canon_enc;\r
 189     int canon_enclen;\r
 190 } /* X509_NAME */ ;\r
 191 \r
 192 DECLARE_STACK_OF(X509_NAME)\r
 193 \r
 194 # define X509_EX_V_NETSCAPE_HACK         0x8000\r
 195 # define X509_EX_V_INIT                  0x0001\r
 196 typedef struct X509_extension_st {\r
 197     ASN1_OBJECT *object;\r
 198     ASN1_BOOLEAN critical;\r
 199     ASN1_OCTET_STRING *value;\r
 200 } X509_EXTENSION;\r
 201 \r
 202 typedef STACK_OF(X509_EXTENSION) X509_EXTENSIONS;\r
 203 \r
 204 DECLARE_STACK_OF(X509_EXTENSION)\r
 205 DECLARE_ASN1_SET_OF(X509_EXTENSION)\r
 206 \r
 207 /* a sequence of these are used */\r
 208 typedef struct x509_attributes_st {\r
 209     ASN1_OBJECT *object;\r
 210     int single;                 /* 0 for a set, 1 for a single item (which is\r
 211                                  * wrong) */\r
 212     union {\r
 213         char *ptr;\r
 214         /*\r
 215          * 0\r
 216          */ STACK_OF(ASN1_TYPE) *set;\r
 217         /*\r
 218          * 1\r
 219          */ ASN1_TYPE *single;\r
 220     } value;\r
 221 } X509_ATTRIBUTE;\r
 222 \r
 223 DECLARE_STACK_OF(X509_ATTRIBUTE)\r
 224 DECLARE_ASN1_SET_OF(X509_ATTRIBUTE)\r
 225 \r
 226 typedef struct X509_req_info_st {\r
 227     ASN1_ENCODING enc;\r
 228     ASN1_INTEGER *version;\r
 229     X509_NAME *subject;\r
 230     X509_PUBKEY *pubkey;\r
 231     /*  d=2 hl=2 l=  0 cons: cont: 00 */\r
 232     STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */\r
 233 } X509_REQ_INFO;\r
 234 \r
 235 typedef struct X509_req_st {\r
 236     X509_REQ_INFO *req_info;\r
 237     X509_ALGOR *sig_alg;\r
 238     ASN1_BIT_STRING *signature;\r
 239     int references;\r
 240 } X509_REQ;\r
 241 \r
 242 typedef struct x509_cinf_st {\r
 243     ASN1_INTEGER *version;      /* [ 0 ] default of v1 */\r
 244     ASN1_INTEGER *serialNumber;\r
 245     X509_ALGOR *signature;\r
 246     X509_NAME *issuer;\r
 247     X509_VAL *validity;\r
 248     X509_NAME *subject;\r
 249     X509_PUBKEY *key;\r
 250     ASN1_BIT_STRING *issuerUID; /* [ 1 ] optional in v2 */\r
 251     ASN1_BIT_STRING *subjectUID; /* [ 2 ] optional in v2 */\r
 252     STACK_OF(X509_EXTENSION) *extensions; /* [ 3 ] optional in v3 */\r
 253     ASN1_ENCODING enc;\r
 254 } X509_CINF;\r
 255 \r
 256 /*\r
 257  * This stuff is certificate "auxiliary info" it contains details which are\r
 258  * useful in certificate stores and databases. When used this is tagged onto\r
 259  * the end of the certificate itself\r
 260  */\r
 261 \r
 262 typedef struct x509_cert_aux_st {\r
 263     STACK_OF(ASN1_OBJECT) *trust; /* trusted uses */\r
 264     STACK_OF(ASN1_OBJECT) *reject; /* rejected uses */\r
 265     ASN1_UTF8STRING *alias;     /* "friendly name" */\r
 266     ASN1_OCTET_STRING *keyid;   /* key id of private key */\r
 267     STACK_OF(X509_ALGOR) *other; /* other unspecified info */\r
 268 } X509_CERT_AUX;\r
 269 \r
 270 struct x509_st {\r
 271     X509_CINF *cert_info;\r
 272     X509_ALGOR *sig_alg;\r
 273     ASN1_BIT_STRING *signature;\r
 274     int valid;\r
 275     int references;\r
 276     char *name;\r
 277     CRYPTO_EX_DATA ex_data;\r
 278     /* These contain copies of various extension values */\r
 279     long ex_pathlen;\r
 280     long ex_pcpathlen;\r
 281     unsigned long ex_flags;\r
 282     unsigned long ex_kusage;\r
 283     unsigned long ex_xkusage;\r
 284     unsigned long ex_nscert;\r
 285     ASN1_OCTET_STRING *skid;\r
 286     AUTHORITY_KEYID *akid;\r
 287     X509_POLICY_CACHE *policy_cache;\r
 288     STACK_OF(DIST_POINT) *crldp;\r
 289     STACK_OF(GENERAL_NAME) *altname;\r
 290     NAME_CONSTRAINTS *nc;\r
 291 # ifndef OPENSSL_NO_RFC3779\r
 292     STACK_OF(IPAddressFamily) *rfc3779_addr;\r
 293     struct ASIdentifiers_st *rfc3779_asid;\r
 294 # endif\r
 295 # ifndef OPENSSL_NO_SHA\r
 296     unsigned char sha1_hash[SHA_DIGEST_LENGTH];\r
 297 # endif\r
 298     X509_CERT_AUX *aux;\r
 299 } /* X509 */ ;\r
 300 \r
 301 DECLARE_STACK_OF(X509)\r
 302 DECLARE_ASN1_SET_OF(X509)\r
 303 \r
 304 /* This is used for a table of trust checking functions */\r
 305 \r
 306 typedef struct x509_trust_st {\r
 307     int trust;\r
 308     int flags;\r
 309     int (*check_trust) (struct x509_trust_st *, X509 *, int);\r
 310     char *name;\r
 311     int arg1;\r
 312     void *arg2;\r
 313 } X509_TRUST;\r
 314 \r
 315 DECLARE_STACK_OF(X509_TRUST)\r
 316 \r
 317 typedef struct x509_cert_pair_st {\r
 318     X509 *forward;\r
 319     X509 *reverse;\r
 320 } X509_CERT_PAIR;\r
 321 \r
 322 /* standard trust ids */\r
 323 \r
 324 # define X509_TRUST_DEFAULT      -1/* Only valid in purpose settings */\r
 325 \r
 326 # define X509_TRUST_COMPAT       1\r
 327 # define X509_TRUST_SSL_CLIENT   2\r
 328 # define X509_TRUST_SSL_SERVER   3\r
 329 # define X509_TRUST_EMAIL        4\r
 330 # define X509_TRUST_OBJECT_SIGN  5\r
 331 # define X509_TRUST_OCSP_SIGN    6\r
 332 # define X509_TRUST_OCSP_REQUEST 7\r
 333 # define X509_TRUST_TSA          8\r
 334 \r
 335 /* Keep these up to date! */\r
 336 # define X509_TRUST_MIN          1\r
 337 # define X509_TRUST_MAX          8\r
 338 \r
 339 /* trust_flags values */\r
 340 # define X509_TRUST_DYNAMIC      1\r
 341 # define X509_TRUST_DYNAMIC_NAME 2\r
 342 \r
 343 /* check_trust return codes */\r
 344 \r
 345 # define X509_TRUST_TRUSTED      1\r
 346 # define X509_TRUST_REJECTED     2\r
 347 # define X509_TRUST_UNTRUSTED    3\r
 348 \r
 349 /* Flags for X509_print_ex() */\r
 350 \r
 351 # define X509_FLAG_COMPAT                0\r
 352 # define X509_FLAG_NO_HEADER             1L\r
 353 # define X509_FLAG_NO_VERSION            (1L << 1)\r
 354 # define X509_FLAG_NO_SERIAL             (1L << 2)\r
 355 # define X509_FLAG_NO_SIGNAME            (1L << 3)\r
 356 # define X509_FLAG_NO_ISSUER             (1L << 4)\r
 357 # define X509_FLAG_NO_VALIDITY           (1L << 5)\r
 358 # define X509_FLAG_NO_SUBJECT            (1L << 6)\r
 359 # define X509_FLAG_NO_PUBKEY             (1L << 7)\r
 360 # define X509_FLAG_NO_EXTENSIONS         (1L << 8)\r
 361 # define X509_FLAG_NO_SIGDUMP            (1L << 9)\r
 362 # define X509_FLAG_NO_AUX                (1L << 10)\r
 363 # define X509_FLAG_NO_ATTRIBUTES         (1L << 11)\r
 364 # define X509_FLAG_NO_IDS                (1L << 12)\r
 365 \r
 366 /* Flags specific to X509_NAME_print_ex() */\r
 367 \r
 368 /* The field separator information */\r
 369 \r
 370 # define XN_FLAG_SEP_MASK        (0xf << 16)\r
 371 \r
 372 # define XN_FLAG_COMPAT          0/* Traditional SSLeay: use old\r
 373                                    * X509_NAME_print */\r
 374 # define XN_FLAG_SEP_COMMA_PLUS  (1 << 16)/* RFC2253 ,+ */\r
 375 # define XN_FLAG_SEP_CPLUS_SPC   (2 << 16)/* ,+ spaced: more readable */\r
 376 # define XN_FLAG_SEP_SPLUS_SPC   (3 << 16)/* ;+ spaced */\r
 377 # define XN_FLAG_SEP_MULTILINE   (4 << 16)/* One line per field */\r
 378 \r
 379 # define XN_FLAG_DN_REV          (1 << 20)/* Reverse DN order */\r
 380 \r
 381 /* How the field name is shown */\r
 382 \r
 383 # define XN_FLAG_FN_MASK         (0x3 << 21)\r
 384 \r
 385 # define XN_FLAG_FN_SN           0/* Object short name */\r
 386 # define XN_FLAG_FN_LN           (1 << 21)/* Object long name */\r
 387 # define XN_FLAG_FN_OID          (2 << 21)/* Always use OIDs */\r
 388 # define XN_FLAG_FN_NONE         (3 << 21)/* No field names */\r
 389 \r
 390 # define XN_FLAG_SPC_EQ          (1 << 23)/* Put spaces round '=' */\r
 391 \r
 392 /*\r
 393  * This determines if we dump fields we don't recognise: RFC2253 requires\r
 394  * this.\r
 395  */\r
 396 \r
 397 # define XN_FLAG_DUMP_UNKNOWN_FIELDS (1 << 24)\r
 398 \r
 399 # define XN_FLAG_FN_ALIGN        (1 << 25)/* Align field names to 20\r
 400                                            * characters */\r
 401 \r
 402 /* Complete set of RFC2253 flags */\r
 403 \r
 404 # define XN_FLAG_RFC2253 (ASN1_STRFLGS_RFC2253 | \\r
 405                         XN_FLAG_SEP_COMMA_PLUS | \\r
 406                         XN_FLAG_DN_REV | \\r
 407                         XN_FLAG_FN_SN | \\r
 408                         XN_FLAG_DUMP_UNKNOWN_FIELDS)\r
 409 \r
 410 /* readable oneline form */\r
 411 \r
 412 # define XN_FLAG_ONELINE (ASN1_STRFLGS_RFC2253 | \\r
 413                         ASN1_STRFLGS_ESC_QUOTE | \\r
 414                         XN_FLAG_SEP_CPLUS_SPC | \\r
 415                         XN_FLAG_SPC_EQ | \\r
 416                         XN_FLAG_FN_SN)\r
 417 \r
 418 /* readable multiline form */\r
 419 \r
 420 # define XN_FLAG_MULTILINE (ASN1_STRFLGS_ESC_CTRL | \\r
 421                         ASN1_STRFLGS_ESC_MSB | \\r
 422                         XN_FLAG_SEP_MULTILINE | \\r
 423                         XN_FLAG_SPC_EQ | \\r
 424                         XN_FLAG_FN_LN | \\r
 425                         XN_FLAG_FN_ALIGN)\r
 426 \r
 427 struct x509_revoked_st {\r
 428     ASN1_INTEGER *serialNumber;\r
 429     ASN1_TIME *revocationDate;\r
 430     STACK_OF(X509_EXTENSION) /* optional */ *extensions;\r
 431     /* Set up if indirect CRL */\r
 432     STACK_OF(GENERAL_NAME) *issuer;\r
 433     /* Revocation reason */\r
 434     int reason;\r
 435     int sequence;               /* load sequence */\r
 436 };\r
 437 \r
 438 DECLARE_STACK_OF(X509_REVOKED)\r
 439 DECLARE_ASN1_SET_OF(X509_REVOKED)\r
 440 \r
 441 typedef struct X509_crl_info_st {\r
 442     ASN1_INTEGER *version;\r
 443     X509_ALGOR *sig_alg;\r
 444     X509_NAME *issuer;\r
 445     ASN1_TIME *lastUpdate;\r
 446     ASN1_TIME *nextUpdate;\r
 447     STACK_OF(X509_REVOKED) *revoked;\r
 448     STACK_OF(X509_EXTENSION) /* [0] */ *extensions;\r
 449     ASN1_ENCODING enc;\r
 450 } X509_CRL_INFO;\r
 451 \r
 452 struct X509_crl_st {\r
 453     /* actual signature */\r
 454     X509_CRL_INFO *crl;\r
 455     X509_ALGOR *sig_alg;\r
 456     ASN1_BIT_STRING *signature;\r
 457     int references;\r
 458     int flags;\r
 459     /* Copies of various extensions */\r
 460     AUTHORITY_KEYID *akid;\r
 461     ISSUING_DIST_POINT *idp;\r
 462     /* Convenient breakdown of IDP */\r
 463     int idp_flags;\r
 464     int idp_reasons;\r
 465     /* CRL and base CRL numbers for delta processing */\r
 466     ASN1_INTEGER *crl_number;\r
 467     ASN1_INTEGER *base_crl_number;\r
 468 # ifndef OPENSSL_NO_SHA\r
 469     unsigned char sha1_hash[SHA_DIGEST_LENGTH];\r
 470 # endif\r
 471     STACK_OF(GENERAL_NAMES) *issuers;\r
 472     const X509_CRL_METHOD *meth;\r
 473     void *meth_data;\r
 474 } /* X509_CRL */ ;\r
 475 \r
 476 DECLARE_STACK_OF(X509_CRL)\r
 477 DECLARE_ASN1_SET_OF(X509_CRL)\r
 478 \r
 479 typedef struct private_key_st {\r
 480     int version;\r
 481     /* The PKCS#8 data types */\r
 482     X509_ALGOR *enc_algor;\r
 483     ASN1_OCTET_STRING *enc_pkey; /* encrypted pub key */\r
 484     /* When decrypted, the following will not be NULL */\r
 485     EVP_PKEY *dec_pkey;\r
 486     /* used to encrypt and decrypt */\r
 487     int key_length;\r
 488     char *key_data;\r
 489     int key_free;               /* true if we should auto free key_data */\r
 490     /* expanded version of 'enc_algor' */\r
 491     EVP_CIPHER_INFO cipher;\r
 492     int references;\r
 493 } X509_PKEY;\r
 494 \r
 495 # ifndef OPENSSL_NO_EVP\r
 496 typedef struct X509_info_st {\r
 497     X509 *x509;\r
 498     X509_CRL *crl;\r
 499     X509_PKEY *x_pkey;\r
 500     EVP_CIPHER_INFO enc_cipher;\r
 501     int enc_len;\r
 502     char *enc_data;\r
 503     int references;\r
 504 } X509_INFO;\r
 505 \r
 506 DECLARE_STACK_OF(X509_INFO)\r
 507 # endif\r
 508 \r
 509 /*\r
 510  * The next 2 structures and their 8 routines were sent to me by Pat Richard\r
 511  * <patr@x509.com> and are used to manipulate Netscapes spki structures -\r
 512  * useful if you are writing a CA web page\r
 513  */\r
 514 typedef struct Netscape_spkac_st {\r
 515     X509_PUBKEY *pubkey;\r
 516     ASN1_IA5STRING *challenge;  /* challenge sent in atlas >= PR2 */\r
 517 } NETSCAPE_SPKAC;\r
 518 \r
 519 typedef struct Netscape_spki_st {\r
 520     NETSCAPE_SPKAC *spkac;      /* signed public key and challenge */\r
 521     X509_ALGOR *sig_algor;\r
 522     ASN1_BIT_STRING *signature;\r
 523 } NETSCAPE_SPKI;\r
 524 \r
 525 /* Netscape certificate sequence structure */\r
 526 typedef struct Netscape_certificate_sequence {\r
 527     ASN1_OBJECT *type;\r
 528     STACK_OF(X509) *certs;\r
 529 } NETSCAPE_CERT_SEQUENCE;\r
 530 \r
 531 /*- Unused (and iv length is wrong)\r
 532 typedef struct CBCParameter_st\r
 533         {\r
 534         unsigned char iv[8];\r
 535         } CBC_PARAM;\r
 536 */\r
 537 \r
 538 /* Password based encryption structure */\r
 539 \r
 540 typedef struct PBEPARAM_st {\r
 541     ASN1_OCTET_STRING *salt;\r
 542     ASN1_INTEGER *iter;\r
 543 } PBEPARAM;\r
 544 \r
 545 /* Password based encryption V2 structures */\r
 546 \r
 547 typedef struct PBE2PARAM_st {\r
 548     X509_ALGOR *keyfunc;\r
 549     X509_ALGOR *encryption;\r
 550 } PBE2PARAM;\r
 551 \r
 552 typedef struct PBKDF2PARAM_st {\r
 553 /* Usually OCTET STRING but could be anything */\r
 554     ASN1_TYPE *salt;\r
 555     ASN1_INTEGER *iter;\r
 556     ASN1_INTEGER *keylength;\r
 557     X509_ALGOR *prf;\r
 558 } PBKDF2PARAM;\r
 559 \r
 560 /* PKCS#8 private key info structure */\r
 561 \r
 562 struct pkcs8_priv_key_info_st {\r
 563     /* Flag for various broken formats */\r
 564     int broken;\r
 565 # define PKCS8_OK                0\r
 566 # define PKCS8_NO_OCTET          1\r
 567 # define PKCS8_EMBEDDED_PARAM    2\r
 568 # define PKCS8_NS_DB             3\r
 569 # define PKCS8_NEG_PRIVKEY       4\r
 570     ASN1_INTEGER *version;\r
 571     X509_ALGOR *pkeyalg;\r
 572     /* Should be OCTET STRING but some are broken */\r
 573     ASN1_TYPE *pkey;\r
 574     STACK_OF(X509_ATTRIBUTE) *attributes;\r
 575 };\r
 576 \r
 577 #ifdef  __cplusplus\r
 578 }\r
 579 #endif\r
 580 \r
 581 # include <openssl/x509_vfy.h>\r
 582 # include <openssl/pkcs7.h>\r
 583 \r
 584 #ifdef  __cplusplus\r
 585 extern "C" {\r
 586 #endif\r
 587 \r
 588 # define X509_EXT_PACK_UNKNOWN   1\r
 589 # define X509_EXT_PACK_STRING    2\r
 590 \r
 591 # define         X509_get_version(x) ASN1_INTEGER_get((x)->cert_info->version)\r
 592 /* #define      X509_get_serialNumber(x) ((x)->cert_info->serialNumber) */\r
 593 # define         X509_get_notBefore(x) ((x)->cert_info->validity->notBefore)\r
 594 # define         X509_get_notAfter(x) ((x)->cert_info->validity->notAfter)\r
 595 # define         X509_extract_key(x)     X509_get_pubkey(x)/*****/\r
 596 # define         X509_REQ_get_version(x) ASN1_INTEGER_get((x)->req_info->version)\r
 597 # define         X509_REQ_get_subject_name(x) ((x)->req_info->subject)\r
 598 # define         X509_REQ_extract_key(a) X509_REQ_get_pubkey(a)\r
 599 # define         X509_name_cmp(a,b)      X509_NAME_cmp((a),(b))\r
 600 # define         X509_get_signature_type(x) EVP_PKEY_type(OBJ_obj2nid((x)->sig_alg->algorithm))\r
 601 \r
 602 # define         X509_CRL_get_version(x) ASN1_INTEGER_get((x)->crl->version)\r
 603 # define         X509_CRL_get_lastUpdate(x) ((x)->crl->lastUpdate)\r
 604 # define         X509_CRL_get_nextUpdate(x) ((x)->crl->nextUpdate)\r
 605 # define         X509_CRL_get_issuer(x) ((x)->crl->issuer)\r
 606 # define         X509_CRL_get_REVOKED(x) ((x)->crl->revoked)\r
 607 \r
 608 void X509_CRL_set_default_method(const X509_CRL_METHOD *meth);\r
 609 X509_CRL_METHOD *X509_CRL_METHOD_new(int (*crl_init) (X509_CRL *crl),\r
 610                                      int (*crl_free) (X509_CRL *crl),\r
 611                                      int (*crl_lookup) (X509_CRL *crl,\r
 612                                                         X509_REVOKED **ret,\r
 613                                                         ASN1_INTEGER *ser,\r
 614                                                         X509_NAME *issuer),\r
 615                                      int (*crl_verify) (X509_CRL *crl,\r
 616                                                         EVP_PKEY *pk));\r
 617 void X509_CRL_METHOD_free(X509_CRL_METHOD *m);\r
 618 \r
 619 void X509_CRL_set_meth_data(X509_CRL *crl, void *dat);\r
 620 void *X509_CRL_get_meth_data(X509_CRL *crl);\r
 621 \r
 622 /*\r
 623  * This one is only used so that a binary form can output, as in\r
 624  * i2d_X509_NAME(X509_get_X509_PUBKEY(x),&buf)\r
 625  */\r
 626 # define         X509_get_X509_PUBKEY(x) ((x)->cert_info->key)\r
 627 \r
 628 const char *X509_verify_cert_error_string(long n);\r
 629 \r
 630 # ifndef OPENSSL_NO_EVP\r
 631 int X509_verify(X509 *a, EVP_PKEY *r);\r
 632 \r
 633 int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r);\r
 634 int X509_CRL_verify(X509_CRL *a, EVP_PKEY *r);\r
 635 int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r);\r
 636 \r
 637 NETSCAPE_SPKI *NETSCAPE_SPKI_b64_decode(const char *str, int len);\r
 638 char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *x);\r
 639 EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x);\r
 640 int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey);\r
 641 \r
 642 int NETSCAPE_SPKI_print(BIO *out, NETSCAPE_SPKI *spki);\r
 643 \r
 644 int X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent);\r
 645 int X509_signature_print(BIO *bp, X509_ALGOR *alg, ASN1_STRING *sig);\r
 646 \r
 647 int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);\r
 648 int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx);\r
 649 int X509_http_nbio(OCSP_REQ_CTX *rctx, X509 **pcert);\r
 650 int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md);\r
 651 int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx);\r
 652 int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md);\r
 653 int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx);\r
 654 int X509_CRL_http_nbio(OCSP_REQ_CTX *rctx, X509_CRL **pcrl);\r
 655 int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md);\r
 656 \r
 657 int X509_pubkey_digest(const X509 *data, const EVP_MD *type,\r
 658                        unsigned char *md, unsigned int *len);\r
 659 int X509_digest(const X509 *data, const EVP_MD *type,\r
 660                 unsigned char *md, unsigned int *len);\r
 661 int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type,\r
 662                     unsigned char *md, unsigned int *len);\r
 663 int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type,\r
 664                     unsigned char *md, unsigned int *len);\r
 665 int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type,\r
 666                      unsigned char *md, unsigned int *len);\r
 667 # endif\r
 668 \r
 669 # ifndef OPENSSL_NO_FP_API\r
 670 X509 *d2i_X509_fp(FILE *fp, X509 **x509);\r
 671 int i2d_X509_fp(FILE *fp, X509 *x509);\r
 672 X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl);\r
 673 int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl);\r
 674 X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req);\r
 675 int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req);\r
 676 #  ifndef OPENSSL_NO_RSA\r
 677 RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa);\r
 678 int i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa);\r
 679 RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa);\r
 680 int i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa);\r
 681 RSA *d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa);\r
 682 int i2d_RSA_PUBKEY_fp(FILE *fp, RSA *rsa);\r
 683 #  endif\r
 684 #  ifndef OPENSSL_NO_DSA\r
 685 DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa);\r
 686 int i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa);\r
 687 DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa);\r
 688 int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa);\r
 689 #  endif\r
 690 #  ifndef OPENSSL_NO_EC\r
 691 EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey);\r
 692 int i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey);\r
 693 EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey);\r
 694 int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey);\r
 695 #  endif\r
 696 X509_SIG *d2i_PKCS8_fp(FILE *fp, X509_SIG **p8);\r
 697 int i2d_PKCS8_fp(FILE *fp, X509_SIG *p8);\r
 698 PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,\r
 699                                                 PKCS8_PRIV_KEY_INFO **p8inf);\r
 700 int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf);\r
 701 int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key);\r
 702 int i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey);\r
 703 EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a);\r
 704 int i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey);\r
 705 EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a);\r
 706 # endif\r
 707 \r
 708 # ifndef OPENSSL_NO_BIO\r
 709 X509 *d2i_X509_bio(BIO *bp, X509 **x509);\r
 710 int i2d_X509_bio(BIO *bp, X509 *x509);\r
 711 X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl);\r
 712 int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl);\r
 713 X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req);\r
 714 int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req);\r
 715 #  ifndef OPENSSL_NO_RSA\r
 716 RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa);\r
 717 int i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa);\r
 718 RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa);\r
 719 int i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa);\r
 720 RSA *d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa);\r
 721 int i2d_RSA_PUBKEY_bio(BIO *bp, RSA *rsa);\r
 722 #  endif\r
 723 #  ifndef OPENSSL_NO_DSA\r
 724 DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa);\r
 725 int i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa);\r
 726 DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa);\r
 727 int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa);\r
 728 #  endif\r
 729 #  ifndef OPENSSL_NO_EC\r
 730 EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey);\r
 731 int i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *eckey);\r
 732 EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey);\r
 733 int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey);\r
 734 #  endif\r
 735 X509_SIG *d2i_PKCS8_bio(BIO *bp, X509_SIG **p8);\r
 736 int i2d_PKCS8_bio(BIO *bp, X509_SIG *p8);\r
 737 PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,\r
 738                                                  PKCS8_PRIV_KEY_INFO **p8inf);\r
 739 int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf);\r
 740 int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key);\r
 741 int i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey);\r
 742 EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a);\r
 743 int i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey);\r
 744 EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a);\r
 745 # endif\r
 746 \r
 747 X509 *X509_dup(X509 *x509);\r
 748 X509_ATTRIBUTE *X509_ATTRIBUTE_dup(X509_ATTRIBUTE *xa);\r
 749 X509_EXTENSION *X509_EXTENSION_dup(X509_EXTENSION *ex);\r
 750 X509_CRL *X509_CRL_dup(X509_CRL *crl);\r
 751 X509_REVOKED *X509_REVOKED_dup(X509_REVOKED *rev);\r
 752 X509_REQ *X509_REQ_dup(X509_REQ *req);\r
 753 X509_ALGOR *X509_ALGOR_dup(X509_ALGOR *xn);\r
 754 int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype,\r
 755                     void *pval);\r
 756 void X509_ALGOR_get0(ASN1_OBJECT **paobj, int *pptype, void **ppval,\r
 757                      X509_ALGOR *algor);\r
 758 void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md);\r
 759 int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b);\r
 760 \r
 761 X509_NAME *X509_NAME_dup(X509_NAME *xn);\r
 762 X509_NAME_ENTRY *X509_NAME_ENTRY_dup(X509_NAME_ENTRY *ne);\r
 763 \r
 764 int X509_cmp_time(const ASN1_TIME *s, time_t *t);\r
 765 int X509_cmp_current_time(const ASN1_TIME *s);\r
 766 ASN1_TIME *X509_time_adj(ASN1_TIME *s, long adj, time_t *t);\r
 767 ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s,\r
 768                             int offset_day, long offset_sec, time_t *t);\r
 769 ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj);\r
 770 \r
 771 const char *X509_get_default_cert_area(void);\r
 772 const char *X509_get_default_cert_dir(void);\r
 773 const char *X509_get_default_cert_file(void);\r
 774 const char *X509_get_default_cert_dir_env(void);\r
 775 const char *X509_get_default_cert_file_env(void);\r
 776 const char *X509_get_default_private_dir(void);\r
 777 \r
 778 X509_REQ *X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);\r
 779 X509 *X509_REQ_to_X509(X509_REQ *r, int days, EVP_PKEY *pkey);\r
 780 \r
 781 DECLARE_ASN1_FUNCTIONS(X509_ALGOR)\r
 782 DECLARE_ASN1_ENCODE_FUNCTIONS(X509_ALGORS, X509_ALGORS, X509_ALGORS)\r
 783 DECLARE_ASN1_FUNCTIONS(X509_VAL)\r
 784 \r
 785 DECLARE_ASN1_FUNCTIONS(X509_PUBKEY)\r
 786 \r
 787 int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey);\r
 788 EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key);\r
 789 int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain);\r
 790 int i2d_PUBKEY(EVP_PKEY *a, unsigned char **pp);\r
 791 EVP_PKEY *d2i_PUBKEY(EVP_PKEY **a, const unsigned char **pp, long length);\r
 792 # ifndef OPENSSL_NO_RSA\r
 793 int i2d_RSA_PUBKEY(RSA *a, unsigned char **pp);\r
 794 RSA *d2i_RSA_PUBKEY(RSA **a, const unsigned char **pp, long length);\r
 795 # endif\r
 796 # ifndef OPENSSL_NO_DSA\r
 797 int i2d_DSA_PUBKEY(DSA *a, unsigned char **pp);\r
 798 DSA *d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp, long length);\r
 799 # endif\r
 800 # ifndef OPENSSL_NO_EC\r
 801 int i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp);\r
 802 EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length);\r
 803 # endif\r
 804 \r
 805 DECLARE_ASN1_FUNCTIONS(X509_SIG)\r
 806 DECLARE_ASN1_FUNCTIONS(X509_REQ_INFO)\r
 807 DECLARE_ASN1_FUNCTIONS(X509_REQ)\r
 808 \r
 809 DECLARE_ASN1_FUNCTIONS(X509_ATTRIBUTE)\r
 810 X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, void *value);\r
 811 \r
 812 DECLARE_ASN1_FUNCTIONS(X509_EXTENSION)\r
 813 DECLARE_ASN1_ENCODE_FUNCTIONS(X509_EXTENSIONS, X509_EXTENSIONS, X509_EXTENSIONS)\r
 814 \r
 815 DECLARE_ASN1_FUNCTIONS(X509_NAME_ENTRY)\r
 816 \r
 817 DECLARE_ASN1_FUNCTIONS(X509_NAME)\r
 818 \r
 819 int X509_NAME_set(X509_NAME **xn, X509_NAME *name);\r
 820 \r
 821 DECLARE_ASN1_FUNCTIONS(X509_CINF)\r
 822 \r
 823 DECLARE_ASN1_FUNCTIONS(X509)\r
 824 DECLARE_ASN1_FUNCTIONS(X509_CERT_AUX)\r
 825 \r
 826 DECLARE_ASN1_FUNCTIONS(X509_CERT_PAIR)\r
 827 \r
 828 int X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,\r
 829                           CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);\r
 830 int X509_set_ex_data(X509 *r, int idx, void *arg);\r
 831 void *X509_get_ex_data(X509 *r, int idx);\r
 832 int i2d_X509_AUX(X509 *a, unsigned char **pp);\r
 833 X509 *d2i_X509_AUX(X509 **a, const unsigned char **pp, long length);\r
 834 \r
 835 int i2d_re_X509_tbs(X509 *x, unsigned char **pp);\r
 836 \r
 837 void X509_get0_signature(ASN1_BIT_STRING **psig, X509_ALGOR **palg,\r
 838                          const X509 *x);\r
 839 int X509_get_signature_nid(const X509 *x);\r
 840 \r
 841 int X509_alias_set1(X509 *x, unsigned char *name, int len);\r
 842 int X509_keyid_set1(X509 *x, unsigned char *id, int len);\r
 843 unsigned char *X509_alias_get0(X509 *x, int *len);\r
 844 unsigned char *X509_keyid_get0(X509 *x, int *len);\r
 845 int (*X509_TRUST_set_default(int (*trust) (int, X509 *, int))) (int, X509 *,\r
 846                                                                 int);\r
 847 int X509_TRUST_set(int *t, int trust);\r
 848 int X509_add1_trust_object(X509 *x, ASN1_OBJECT *obj);\r
 849 int X509_add1_reject_object(X509 *x, ASN1_OBJECT *obj);\r
 850 void X509_trust_clear(X509 *x);\r
 851 void X509_reject_clear(X509 *x);\r
 852 \r
 853 DECLARE_ASN1_FUNCTIONS(X509_REVOKED)\r
 854 DECLARE_ASN1_FUNCTIONS(X509_CRL_INFO)\r
 855 DECLARE_ASN1_FUNCTIONS(X509_CRL)\r
 856 \r
 857 int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev);\r
 858 int X509_CRL_get0_by_serial(X509_CRL *crl,\r
 859                             X509_REVOKED **ret, ASN1_INTEGER *serial);\r
 860 int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x);\r
 861 \r
 862 X509_PKEY *X509_PKEY_new(void);\r
 863 void X509_PKEY_free(X509_PKEY *a);\r
 864 int i2d_X509_PKEY(X509_PKEY *a, unsigned char **pp);\r
 865 X509_PKEY *d2i_X509_PKEY(X509_PKEY **a, const unsigned char **pp,\r
 866                          long length);\r
 867 \r
 868 DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKI)\r
 869 DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKAC)\r
 870 DECLARE_ASN1_FUNCTIONS(NETSCAPE_CERT_SEQUENCE)\r
 871 \r
 872 # ifndef OPENSSL_NO_EVP\r
 873 X509_INFO *X509_INFO_new(void);\r
 874 void X509_INFO_free(X509_INFO *a);\r
 875 char *X509_NAME_oneline(X509_NAME *a, char *buf, int size);\r
 876 \r
 877 int ASN1_verify(i2d_of_void *i2d, X509_ALGOR *algor1,\r
 878                 ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey);\r
 879 \r
 880 int ASN1_digest(i2d_of_void *i2d, const EVP_MD *type, char *data,\r
 881                 unsigned char *md, unsigned int *len);\r
 882 \r
 883 int ASN1_sign(i2d_of_void *i2d, X509_ALGOR *algor1,\r
 884               X509_ALGOR *algor2, ASN1_BIT_STRING *signature,\r
 885               char *data, EVP_PKEY *pkey, const EVP_MD *type);\r
 886 \r
 887 int ASN1_item_digest(const ASN1_ITEM *it, const EVP_MD *type, void *data,\r
 888                      unsigned char *md, unsigned int *len);\r
 889 \r
 890 int ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *algor1,\r
 891                      ASN1_BIT_STRING *signature, void *data, EVP_PKEY *pkey);\r
 892 \r
 893 int ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1,\r
 894                    X509_ALGOR *algor2, ASN1_BIT_STRING *signature, void *data,\r
 895                    EVP_PKEY *pkey, const EVP_MD *type);\r
 896 int ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1,\r
 897                        X509_ALGOR *algor2, ASN1_BIT_STRING *signature,\r
 898                        void *asn, EVP_MD_CTX *ctx);\r
 899 # endif\r
 900 \r
 901 int X509_set_version(X509 *x, long version);\r
 902 int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial);\r
 903 ASN1_INTEGER *X509_get_serialNumber(X509 *x);\r
 904 int X509_set_issuer_name(X509 *x, X509_NAME *name);\r
 905 X509_NAME *X509_get_issuer_name(X509 *a);\r
 906 int X509_set_subject_name(X509 *x, X509_NAME *name);\r
 907 X509_NAME *X509_get_subject_name(X509 *a);\r
 908 int X509_set_notBefore(X509 *x, const ASN1_TIME *tm);\r
 909 int X509_set_notAfter(X509 *x, const ASN1_TIME *tm);\r
 910 int X509_set_pubkey(X509 *x, EVP_PKEY *pkey);\r
 911 EVP_PKEY *X509_get_pubkey(X509 *x);\r
 912 ASN1_BIT_STRING *X509_get0_pubkey_bitstr(const X509 *x);\r
 913 int X509_certificate_type(X509 *x, EVP_PKEY *pubkey /* optional */ );\r
 914 \r
 915 int X509_REQ_set_version(X509_REQ *x, long version);\r
 916 int X509_REQ_set_subject_name(X509_REQ *req, X509_NAME *name);\r
 917 int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey);\r
 918 EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *req);\r
 919 int X509_REQ_extension_nid(int nid);\r
 920 int *X509_REQ_get_extension_nids(void);\r
 921 void X509_REQ_set_extension_nids(int *nids);\r
 922 STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req);\r
 923 int X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts,\r
 924                                 int nid);\r
 925 int X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts);\r
 926 int X509_REQ_get_attr_count(const X509_REQ *req);\r
 927 int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos);\r
 928 int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, ASN1_OBJECT *obj,\r
 929                              int lastpos);\r
 930 X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc);\r
 931 X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc);\r
 932 int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr);\r
 933 int X509_REQ_add1_attr_by_OBJ(X509_REQ *req,\r
 934                               const ASN1_OBJECT *obj, int type,\r
 935                               const unsigned char *bytes, int len);\r
 936 int X509_REQ_add1_attr_by_NID(X509_REQ *req,\r
 937                               int nid, int type,\r
 938                               const unsigned char *bytes, int len);\r
 939 int X509_REQ_add1_attr_by_txt(X509_REQ *req,\r
 940                               const char *attrname, int type,\r
 941                               const unsigned char *bytes, int len);\r
 942 \r
 943 int X509_CRL_set_version(X509_CRL *x, long version);\r
 944 int X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name);\r
 945 int X509_CRL_set_lastUpdate(X509_CRL *x, const ASN1_TIME *tm);\r
 946 int X509_CRL_set_nextUpdate(X509_CRL *x, const ASN1_TIME *tm);\r
 947 int X509_CRL_sort(X509_CRL *crl);\r
 948 \r
 949 int X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial);\r
 950 int X509_REVOKED_set_revocationDate(X509_REVOKED *r, ASN1_TIME *tm);\r
 951 \r
 952 X509_CRL *X509_CRL_diff(X509_CRL *base, X509_CRL *newer,\r
 953                         EVP_PKEY *skey, const EVP_MD *md, unsigned int flags);\r
 954 \r
 955 int X509_REQ_check_private_key(X509_REQ *x509, EVP_PKEY *pkey);\r
 956 \r
 957 int X509_check_private_key(X509 *x509, EVP_PKEY *pkey);\r
 958 int X509_chain_check_suiteb(int *perror_depth,\r
 959                             X509 *x, STACK_OF(X509) *chain,\r
 960                             unsigned long flags);\r
 961 int X509_CRL_check_suiteb(X509_CRL *crl, EVP_PKEY *pk, unsigned long flags);\r
 962 STACK_OF(X509) *X509_chain_up_ref(STACK_OF(X509) *chain);\r
 963 \r
 964 int X509_issuer_and_serial_cmp(const X509 *a, const X509 *b);\r
 965 unsigned long X509_issuer_and_serial_hash(X509 *a);\r
 966 \r
 967 int X509_issuer_name_cmp(const X509 *a, const X509 *b);\r
 968 unsigned long X509_issuer_name_hash(X509 *a);\r
 969 \r
 970 int X509_subject_name_cmp(const X509 *a, const X509 *b);\r
 971 unsigned long X509_subject_name_hash(X509 *x);\r
 972 \r
 973 # ifndef OPENSSL_NO_MD5\r
 974 unsigned long X509_issuer_name_hash_old(X509 *a);\r
 975 unsigned long X509_subject_name_hash_old(X509 *x);\r
 976 # endif\r
 977 \r
 978 int X509_cmp(const X509 *a, const X509 *b);\r
 979 int X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b);\r
 980 unsigned long X509_NAME_hash(X509_NAME *x);\r
 981 unsigned long X509_NAME_hash_old(X509_NAME *x);\r
 982 \r
 983 int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b);\r
 984 int X509_CRL_match(const X509_CRL *a, const X509_CRL *b);\r
 985 # ifndef OPENSSL_NO_FP_API\r
 986 int X509_print_ex_fp(FILE *bp, X509 *x, unsigned long nmflag,\r
 987                      unsigned long cflag);\r
 988 int X509_print_fp(FILE *bp, X509 *x);\r
 989 int X509_CRL_print_fp(FILE *bp, X509_CRL *x);\r
 990 int X509_REQ_print_fp(FILE *bp, X509_REQ *req);\r
 991 int X509_NAME_print_ex_fp(FILE *fp, X509_NAME *nm, int indent,\r
 992                           unsigned long flags);\r
 993 # endif\r
 994 \r
 995 # ifndef OPENSSL_NO_BIO\r
 996 int X509_NAME_print(BIO *bp, X509_NAME *name, int obase);\r
 997 int X509_NAME_print_ex(BIO *out, X509_NAME *nm, int indent,\r
 998                        unsigned long flags);\r
 999 int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflag,\r
1000                   unsigned long cflag);\r
1001 int X509_print(BIO *bp, X509 *x);\r
1002 int X509_ocspid_print(BIO *bp, X509 *x);\r
1003 int X509_CERT_AUX_print(BIO *bp, X509_CERT_AUX *x, int indent);\r
1004 int X509_CRL_print(BIO *bp, X509_CRL *x);\r
1005 int X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag,\r
1006                       unsigned long cflag);\r
1007 int X509_REQ_print(BIO *bp, X509_REQ *req);\r
1008 # endif\r
1009 \r
1010 int X509_NAME_entry_count(X509_NAME *name);\r
1011 int X509_NAME_get_text_by_NID(X509_NAME *name, int nid, char *buf, int len);\r
1012 int X509_NAME_get_text_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj,\r
1013                               char *buf, int len);\r
1014 \r
1015 /*\r
1016  * NOTE: you should be passsing -1, not 0 as lastpos.  The functions that use\r
1017  * lastpos, search after that position on.\r
1018  */\r
1019 int X509_NAME_get_index_by_NID(X509_NAME *name, int nid, int lastpos);\r
1020 int X509_NAME_get_index_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj,\r
1021                                int lastpos);\r
1022 X509_NAME_ENTRY *X509_NAME_get_entry(X509_NAME *name, int loc);\r
1023 X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc);\r
1024 int X509_NAME_add_entry(X509_NAME *name, X509_NAME_ENTRY *ne,\r
1025                         int loc, int set);\r
1026 int X509_NAME_add_entry_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj, int type,\r
1027                                unsigned char *bytes, int len, int loc,\r
1028                                int set);\r
1029 int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,\r
1030                                unsigned char *bytes, int len, int loc,\r
1031                                int set);\r
1032 X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,\r
1033                                                const char *field, int type,\r
1034                                                const unsigned char *bytes,\r
1035                                                int len);\r
1036 X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid,\r
1037                                                int type, unsigned char *bytes,\r
1038                                                int len);\r
1039 int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,\r
1040                                const unsigned char *bytes, int len, int loc,\r
1041                                int set);\r
1042 X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne,\r
1043                                                ASN1_OBJECT *obj, int type,\r
1044                                                const unsigned char *bytes,\r
1045                                                int len);\r
1046 int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, ASN1_OBJECT *obj);\r
1047 int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,\r
1048                              const unsigned char *bytes, int len);\r
1049 ASN1_OBJECT *X509_NAME_ENTRY_get_object(X509_NAME_ENTRY *ne);\r
1050 ASN1_STRING *X509_NAME_ENTRY_get_data(X509_NAME_ENTRY *ne);\r
1051 \r
1052 int X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x);\r
1053 int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x,\r
1054                           int nid, int lastpos);\r
1055 int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *x,\r
1056                           ASN1_OBJECT *obj, int lastpos);\r
1057 int X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *x,\r
1058                                int crit, int lastpos);\r
1059 X509_EXTENSION *X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc);\r
1060 X509_EXTENSION *X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc);\r
1061 STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x,\r
1062                                          X509_EXTENSION *ex, int loc);\r
1063 \r
1064 int X509_get_ext_count(X509 *x);\r
1065 int X509_get_ext_by_NID(X509 *x, int nid, int lastpos);\r
1066 int X509_get_ext_by_OBJ(X509 *x, ASN1_OBJECT *obj, int lastpos);\r
1067 int X509_get_ext_by_critical(X509 *x, int crit, int lastpos);\r
1068 X509_EXTENSION *X509_get_ext(X509 *x, int loc);\r
1069 X509_EXTENSION *X509_delete_ext(X509 *x, int loc);\r
1070 int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc);\r
1071 void *X509_get_ext_d2i(X509 *x, int nid, int *crit, int *idx);\r
1072 int X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit,\r
1073                       unsigned long flags);\r
1074 \r
1075 int X509_CRL_get_ext_count(X509_CRL *x);\r
1076 int X509_CRL_get_ext_by_NID(X509_CRL *x, int nid, int lastpos);\r
1077 int X509_CRL_get_ext_by_OBJ(X509_CRL *x, ASN1_OBJECT *obj, int lastpos);\r
1078 int X509_CRL_get_ext_by_critical(X509_CRL *x, int crit, int lastpos);\r
1079 X509_EXTENSION *X509_CRL_get_ext(X509_CRL *x, int loc);\r
1080 X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc);\r
1081 int X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc);\r
1082 void *X509_CRL_get_ext_d2i(X509_CRL *x, int nid, int *crit, int *idx);\r
1083 int X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit,\r
1084                           unsigned long flags);\r
1085 \r
1086 int X509_REVOKED_get_ext_count(X509_REVOKED *x);\r
1087 int X509_REVOKED_get_ext_by_NID(X509_REVOKED *x, int nid, int lastpos);\r
1088 int X509_REVOKED_get_ext_by_OBJ(X509_REVOKED *x, ASN1_OBJECT *obj,\r
1089                                 int lastpos);\r
1090 int X509_REVOKED_get_ext_by_critical(X509_REVOKED *x, int crit, int lastpos);\r
1091 X509_EXTENSION *X509_REVOKED_get_ext(X509_REVOKED *x, int loc);\r
1092 X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc);\r
1093 int X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc);\r
1094 void *X509_REVOKED_get_ext_d2i(X509_REVOKED *x, int nid, int *crit, int *idx);\r
1095 int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,\r
1096                               unsigned long flags);\r
1097 \r
1098 X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex,\r
1099                                              int nid, int crit,\r
1100                                              ASN1_OCTET_STRING *data);\r
1101 X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex,\r
1102                                              ASN1_OBJECT *obj, int crit,\r
1103                                              ASN1_OCTET_STRING *data);\r
1104 int X509_EXTENSION_set_object(X509_EXTENSION *ex, ASN1_OBJECT *obj);\r
1105 int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit);\r
1106 int X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data);\r
1107 ASN1_OBJECT *X509_EXTENSION_get_object(X509_EXTENSION *ex);\r
1108 ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne);\r
1109 int X509_EXTENSION_get_critical(X509_EXTENSION *ex);\r
1110 \r
1111 int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x);\r
1112 int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,\r
1113                            int lastpos);\r
1114 int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,\r
1115                            ASN1_OBJECT *obj, int lastpos);\r
1116 X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc);\r
1117 X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc);\r
1118 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x,\r
1119                                            X509_ATTRIBUTE *attr);\r
1120 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE)\r
1121                                                   **x, const ASN1_OBJECT *obj,\r
1122                                                   int type,\r
1123                                                   const unsigned char *bytes,\r
1124                                                   int len);\r
1125 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE)\r
1126                                                   **x, int nid, int type,\r
1127                                                   const unsigned char *bytes,\r
1128                                                   int len);\r
1129 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE)\r
1130                                                   **x, const char *attrname,\r
1131                                                   int type,\r
1132                                                   const unsigned char *bytes,\r
1133                                                   int len);\r
1134 void *X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, ASN1_OBJECT *obj,\r
1135                               int lastpos, int type);\r
1136 X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,\r
1137                                              int atrtype, const void *data,\r
1138                                              int len);\r
1139 X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,\r
1140                                              const ASN1_OBJECT *obj,\r
1141                                              int atrtype, const void *data,\r
1142                                              int len);\r
1143 X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,\r
1144                                              const char *atrname, int type,\r
1145                                              const unsigned char *bytes,\r
1146                                              int len);\r
1147 int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj);\r
1148 int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype,\r
1149                              const void *data, int len);\r
1150 void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype,\r
1151                                void *data);\r
1152 int X509_ATTRIBUTE_count(X509_ATTRIBUTE *attr);\r
1153 ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr);\r
1154 ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx);\r
1155 \r
1156 int EVP_PKEY_get_attr_count(const EVP_PKEY *key);\r
1157 int EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid, int lastpos);\r
1158 int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, ASN1_OBJECT *obj,\r
1159                              int lastpos);\r
1160 X509_ATTRIBUTE *EVP_PKEY_get_attr(const EVP_PKEY *key, int loc);\r
1161 X509_ATTRIBUTE *EVP_PKEY_delete_attr(EVP_PKEY *key, int loc);\r
1162 int EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr);\r
1163 int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key,\r
1164                               const ASN1_OBJECT *obj, int type,\r
1165                               const unsigned char *bytes, int len);\r
1166 int EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key,\r
1167                               int nid, int type,\r
1168                               const unsigned char *bytes, int len);\r
1169 int EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key,\r
1170                               const char *attrname, int type,\r
1171                               const unsigned char *bytes, int len);\r
1172 \r
1173 int X509_verify_cert(X509_STORE_CTX *ctx);\r
1174 \r
1175 /* lookup a cert from a X509 STACK */\r
1176 X509 *X509_find_by_issuer_and_serial(STACK_OF(X509) *sk, X509_NAME *name,\r
1177                                      ASN1_INTEGER *serial);\r
1178 X509 *X509_find_by_subject(STACK_OF(X509) *sk, X509_NAME *name);\r
1179 \r
1180 DECLARE_ASN1_FUNCTIONS(PBEPARAM)\r
1181 DECLARE_ASN1_FUNCTIONS(PBE2PARAM)\r
1182 DECLARE_ASN1_FUNCTIONS(PBKDF2PARAM)\r
1183 \r
1184 int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,\r
1185                          const unsigned char *salt, int saltlen);\r
1186 \r
1187 X509_ALGOR *PKCS5_pbe_set(int alg, int iter,\r
1188                           const unsigned char *salt, int saltlen);\r
1189 X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter,\r
1190                            unsigned char *salt, int saltlen);\r
1191 X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter,\r
1192                               unsigned char *salt, int saltlen,\r
1193                               unsigned char *aiv, int prf_nid);\r
1194 \r
1195 X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen,\r
1196                              int prf_nid, int keylen);\r
1197 \r
1198 /* PKCS#8 utilities */\r
1199 \r
1200 DECLARE_ASN1_FUNCTIONS(PKCS8_PRIV_KEY_INFO)\r
1201 \r
1202 EVP_PKEY *EVP_PKCS82PKEY(PKCS8_PRIV_KEY_INFO *p8);\r
1203 PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(EVP_PKEY *pkey);\r
1204 PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8_broken(EVP_PKEY *pkey, int broken);\r
1205 PKCS8_PRIV_KEY_INFO *PKCS8_set_broken(PKCS8_PRIV_KEY_INFO *p8, int broken);\r
1206 \r
1207 int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj,\r
1208                     int version, int ptype, void *pval,\r
1209                     unsigned char *penc, int penclen);\r
1210 int PKCS8_pkey_get0(ASN1_OBJECT **ppkalg,\r
1211                     const unsigned char **pk, int *ppklen,\r
1212                     X509_ALGOR **pa, PKCS8_PRIV_KEY_INFO *p8);\r
1213 \r
1214 int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj,\r
1215                            int ptype, void *pval,\r
1216                            unsigned char *penc, int penclen);\r
1217 int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg,\r
1218                            const unsigned char **pk, int *ppklen,\r
1219                            X509_ALGOR **pa, X509_PUBKEY *pub);\r
1220 \r
1221 int X509_check_trust(X509 *x, int id, int flags);\r
1222 int X509_TRUST_get_count(void);\r
1223 X509_TRUST *X509_TRUST_get0(int idx);\r
1224 int X509_TRUST_get_by_id(int id);\r
1225 int X509_TRUST_add(int id, int flags, int (*ck) (X509_TRUST *, X509 *, int),\r
1226                    char *name, int arg1, void *arg2);\r
1227 void X509_TRUST_cleanup(void);\r
1228 int X509_TRUST_get_flags(X509_TRUST *xp);\r
1229 char *X509_TRUST_get0_name(X509_TRUST *xp);\r
1230 int X509_TRUST_get_trust(X509_TRUST *xp);\r
1231 \r
1232 /* BEGIN ERROR CODES */\r
1233 /*\r
1234  * The following lines are auto generated by the script mkerr.pl. Any changes\r
1235  * made after this point may be overwritten when the script is next run.\r
1236  */\r
1237 void ERR_load_X509_strings(void);\r
1238 \r
1239 /* Error codes for the X509 functions. */\r
1240 \r
1241 /* Function codes. */\r
1242 # define X509_F_ADD_CERT_DIR                              100\r
1243 # define X509_F_BY_FILE_CTRL                              101\r
1244 # define X509_F_CHECK_POLICY                              145\r
1245 # define X509_F_DIR_CTRL                                  102\r
1246 # define X509_F_GET_CERT_BY_SUBJECT                       103\r
1247 # define X509_F_NETSCAPE_SPKI_B64_DECODE                  129\r
1248 # define X509_F_NETSCAPE_SPKI_B64_ENCODE                  130\r
1249 # define X509_F_X509AT_ADD1_ATTR                          135\r
1250 # define X509_F_X509V3_ADD_EXT                            104\r
1251 # define X509_F_X509_ATTRIBUTE_CREATE_BY_NID              136\r
1252 # define X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ              137\r
1253 # define X509_F_X509_ATTRIBUTE_CREATE_BY_TXT              140\r
1254 # define X509_F_X509_ATTRIBUTE_GET0_DATA                  139\r
1255 # define X509_F_X509_ATTRIBUTE_SET1_DATA                  138\r
1256 # define X509_F_X509_CHECK_PRIVATE_KEY                    128\r
1257 # define X509_F_X509_CRL_DIFF                             105\r
1258 # define X509_F_X509_CRL_PRINT_FP                         147\r
1259 # define X509_F_X509_EXTENSION_CREATE_BY_NID              108\r
1260 # define X509_F_X509_EXTENSION_CREATE_BY_OBJ              109\r
1261 # define X509_F_X509_GET_PUBKEY_PARAMETERS                110\r
1262 # define X509_F_X509_LOAD_CERT_CRL_FILE                   132\r
1263 # define X509_F_X509_LOAD_CERT_FILE                       111\r
1264 # define X509_F_X509_LOAD_CRL_FILE                        112\r
1265 # define X509_F_X509_NAME_ADD_ENTRY                       113\r
1266 # define X509_F_X509_NAME_ENTRY_CREATE_BY_NID             114\r
1267 # define X509_F_X509_NAME_ENTRY_CREATE_BY_TXT             131\r
1268 # define X509_F_X509_NAME_ENTRY_SET_OBJECT                115\r
1269 # define X509_F_X509_NAME_ONELINE                         116\r
1270 # define X509_F_X509_NAME_PRINT                           117\r
1271 # define X509_F_X509_PRINT_EX_FP                          118\r
1272 # define X509_F_X509_PUBKEY_GET                           119\r
1273 # define X509_F_X509_PUBKEY_SET                           120\r
1274 # define X509_F_X509_REQ_CHECK_PRIVATE_KEY                144\r
1275 # define X509_F_X509_REQ_PRINT_EX                         121\r
1276 # define X509_F_X509_REQ_PRINT_FP                         122\r
1277 # define X509_F_X509_REQ_TO_X509                          123\r
1278 # define X509_F_X509_STORE_ADD_CERT                       124\r
1279 # define X509_F_X509_STORE_ADD_CRL                        125\r
1280 # define X509_F_X509_STORE_CTX_GET1_ISSUER                146\r
1281 # define X509_F_X509_STORE_CTX_INIT                       143\r
1282 # define X509_F_X509_STORE_CTX_NEW                        142\r
1283 # define X509_F_X509_STORE_CTX_PURPOSE_INHERIT            134\r
1284 # define X509_F_X509_TO_X509_REQ                          126\r
1285 # define X509_F_X509_TRUST_ADD                            133\r
1286 # define X509_F_X509_TRUST_SET                            141\r
1287 # define X509_F_X509_VERIFY_CERT                          127\r
1288 \r
1289 /* Reason codes. */\r
1290 # define X509_R_AKID_MISMATCH                             110\r
1291 # define X509_R_BAD_X509_FILETYPE                         100\r
1292 # define X509_R_BASE64_DECODE_ERROR                       118\r
1293 # define X509_R_CANT_CHECK_DH_KEY                         114\r
1294 # define X509_R_CERT_ALREADY_IN_HASH_TABLE                101\r
1295 # define X509_R_CRL_ALREADY_DELTA                         127\r
1296 # define X509_R_CRL_VERIFY_FAILURE                        131\r
1297 # define X509_R_ERR_ASN1_LIB                              102\r
1298 # define X509_R_IDP_MISMATCH                              128\r
1299 # define X509_R_INVALID_DIRECTORY                         113\r
1300 # define X509_R_INVALID_FIELD_NAME                        119\r
1301 # define X509_R_INVALID_TRUST                             123\r
1302 # define X509_R_ISSUER_MISMATCH                           129\r
1303 # define X509_R_KEY_TYPE_MISMATCH                         115\r
1304 # define X509_R_KEY_VALUES_MISMATCH                       116\r
1305 # define X509_R_LOADING_CERT_DIR                          103\r
1306 # define X509_R_LOADING_DEFAULTS                          104\r
1307 # define X509_R_METHOD_NOT_SUPPORTED                      124\r
1308 # define X509_R_NEWER_CRL_NOT_NEWER                       132\r
1309 # define X509_R_NO_CERT_SET_FOR_US_TO_VERIFY              105\r
1310 # define X509_R_NO_CRL_NUMBER                             130\r
1311 # define X509_R_PUBLIC_KEY_DECODE_ERROR                   125\r
1312 # define X509_R_PUBLIC_KEY_ENCODE_ERROR                   126\r
1313 # define X509_R_SHOULD_RETRY                              106\r
1314 # define X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN        107\r
1315 # define X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY            108\r
1316 # define X509_R_UNKNOWN_KEY_TYPE                          117\r
1317 # define X509_R_UNKNOWN_NID                               109\r
1318 # define X509_R_UNKNOWN_PURPOSE_ID                        121\r
1319 # define X509_R_UNKNOWN_TRUST_ID                          120\r
1320 # define X509_R_UNSUPPORTED_ALGORITHM                     111\r
1321 # define X509_R_WRONG_LOOKUP_TYPE                         112\r
1322 # define X509_R_WRONG_TYPE                                122\r
1323 \r
1324 #ifdef  __cplusplus\r
1325 }\r
1326 #endif\r
1327 #endif\r