x509.h 48.8 KB
Newer Older
1
/* crypto/x509/x509.h */
2
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 4 5 6 7
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
8
 *
9 10 11 12 13 14
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15
 *
16 17 18 19 20 21
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
22
 *
23 24 25 26 27 28 29 30 31 32 33 34 35 36
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
37
 * 4. If you include any Windows specific code (or a derivative thereof) from
38 39
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40
 *
41 42 43 44 45 46 47 48 49 50 51
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
52
 *
53 54 55 56 57
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */
B
Bodo Möller 已提交
58 59
/* ====================================================================
 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
60
 * ECDH support in OpenSSL originally developed by
B
Bodo Möller 已提交
61 62
 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
 */
63 64

#ifndef HEADER_X509_H
65 66 67 68
# define HEADER_X509_H

# include <openssl/e_os2.h>
# include <openssl/symhacks.h>
69 70 71
# include <openssl/buffer.h>
# include <openssl/evp.h>
# include <openssl/bio.h>
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
# include <openssl/stack.h>
# include <openssl/asn1.h>
# include <openssl/safestack.h>

# ifndef OPENSSL_NO_EC
#  include <openssl/ec.h>
#  include <openssl/ecdsa.h>
#  include <openssl/ecdh.h>
# endif

# ifdef OPENSSL_USE_DEPRECATED
#  ifndef OPENSSL_NO_RSA
#   include <openssl/rsa.h>
#  endif
#  ifndef OPENSSL_NO_DSA
#   include <openssl/dsa.h>
#  endif
#  ifndef OPENSSL_NO_DH
#   include <openssl/dh.h>
#  endif
# endif

R
Rich Salz 已提交
94
# include <openssl/sha.h>
95
# include <openssl/ossl_typ.h>
96

97 98 99 100
#ifdef  __cplusplus
extern "C" {
#endif

101
# ifdef OPENSSL_SYS_WIN32
102
/* Under Win32 these are defined in wincrypt.h */
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
#  undef X509_NAME
#  undef X509_EXTENSIONS
# endif

# define X509_FILETYPE_PEM       1
# define X509_FILETYPE_ASN1      2
# define X509_FILETYPE_DEFAULT   3

# define X509v3_KU_DIGITAL_SIGNATURE     0x0080
# define X509v3_KU_NON_REPUDIATION       0x0040
# define X509v3_KU_KEY_ENCIPHERMENT      0x0020
# define X509v3_KU_DATA_ENCIPHERMENT     0x0010
# define X509v3_KU_KEY_AGREEMENT         0x0008
# define X509v3_KU_KEY_CERT_SIGN         0x0004
# define X509v3_KU_CRL_SIGN              0x0002
# define X509v3_KU_ENCIPHER_ONLY         0x0001
# define X509v3_KU_DECIPHER_ONLY         0x8000
# define X509v3_KU_UNDEF                 0xffff

struct X509_algor_st {
    ASN1_OBJECT *algorithm;
    ASN1_TYPE *parameter;
} /* X509_ALGOR */ ;
126

D
Dr. Stephen Henson 已提交
127 128
typedef STACK_OF(X509_ALGOR) X509_ALGORS;

129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
typedef struct X509_val_st {
    ASN1_TIME *notBefore;
    ASN1_TIME *notAfter;
} X509_VAL;

struct X509_pubkey_st {
    X509_ALGOR *algor;
    ASN1_BIT_STRING *public_key;
    EVP_PKEY *pkey;
};

typedef struct X509_sig_st {
    X509_ALGOR *algor;
    ASN1_OCTET_STRING *digest;
} X509_SIG;

D
Dr. Stephen Henson 已提交
145
typedef struct X509_name_entry_st X509_NAME_ENTRY;
146

B
Ben Laurie 已提交
147 148
DECLARE_STACK_OF(X509_NAME_ENTRY)

B
Ben Laurie 已提交
149 150
DECLARE_STACK_OF(X509_NAME)

151 152
# define X509_EX_V_NETSCAPE_HACK         0x8000
# define X509_EX_V_INIT                  0x0001
D
Dr. Stephen Henson 已提交
153
typedef struct X509_extension_st X509_EXTENSION;
154

155 156
typedef STACK_OF(X509_EXTENSION) X509_EXTENSIONS;

B
Ben Laurie 已提交
157 158
DECLARE_STACK_OF(X509_EXTENSION)

D
Dr. Stephen Henson 已提交
159
typedef struct x509_attributes_st X509_ATTRIBUTE;
B
Ben Laurie 已提交
160 161 162

DECLARE_STACK_OF(X509_ATTRIBUTE)

D
Dr. Stephen Henson 已提交
163
typedef struct X509_req_info_st X509_REQ_INFO;
164

D
Dr. Stephen Henson 已提交
165
typedef struct X509_req_st X509_REQ;
166 167 168 169

typedef struct x509_cinf_st {
    ASN1_INTEGER *version;      /* [ 0 ] default of v1 */
    ASN1_INTEGER *serialNumber;
170
    X509_ALGOR signature;
171
    X509_NAME *issuer;
172
    X509_VAL validity;
173 174 175 176 177 178 179 180
    X509_NAME *subject;
    X509_PUBKEY *key;
    ASN1_BIT_STRING *issuerUID; /* [ 1 ] optional in v2 */
    ASN1_BIT_STRING *subjectUID; /* [ 2 ] optional in v2 */
    STACK_OF(X509_EXTENSION) *extensions; /* [ 3 ] optional in v3 */
    ASN1_ENCODING enc;
} X509_CINF;

D
Dr. Stephen Henson 已提交
181
typedef struct x509_cert_aux_st X509_CERT_AUX;
182 183

struct x509_st {
D
Dr. Stephen Henson 已提交
184
    X509_CINF cert_info;
185
    X509_ALGOR sig_alg;
186 187 188 189 190 191 192 193
    ASN1_BIT_STRING *signature;
    int valid;
    int references;
    char *name;
    CRYPTO_EX_DATA ex_data;
    /* These contain copies of various extension values */
    long ex_pathlen;
    long ex_pcpathlen;
194 195 196 197
    uint32_t ex_flags;
    uint32_t ex_kusage;
    uint32_t ex_xkusage;
    uint32_t ex_nscert;
198 199 200 201 202 203
    ASN1_OCTET_STRING *skid;
    AUTHORITY_KEYID *akid;
    X509_POLICY_CACHE *policy_cache;
    STACK_OF(DIST_POINT) *crldp;
    STACK_OF(GENERAL_NAME) *altname;
    NAME_CONSTRAINTS *nc;
204
#ifndef OPENSSL_NO_RFC3779
205 206
    STACK_OF(IPAddressFamily) *rfc3779_addr;
    struct ASIdentifiers_st *rfc3779_asid;
207
# endif
208 209 210
    unsigned char sha1_hash[SHA_DIGEST_LENGTH];
    X509_CERT_AUX *aux;
} /* X509 */ ;
211

B
Ben Laurie 已提交
212 213
DECLARE_STACK_OF(X509)

214 215 216
/* This is used for a table of trust checking functions */

typedef struct x509_trust_st {
217 218 219 220 221 222
    int trust;
    int flags;
    int (*check_trust) (struct x509_trust_st *, X509 *, int);
    char *name;
    int arg1;
    void *arg2;
223 224
} X509_TRUST;

225 226 227
DECLARE_STACK_OF(X509_TRUST)

/* standard trust ids */
228

229
# define X509_TRUST_DEFAULT      -1/* Only valid in purpose settings */
230

231 232 233 234 235 236 237 238
# define X509_TRUST_COMPAT       1
# define X509_TRUST_SSL_CLIENT   2
# define X509_TRUST_SSL_SERVER   3
# define X509_TRUST_EMAIL        4
# define X509_TRUST_OBJECT_SIGN  5
# define X509_TRUST_OCSP_SIGN    6
# define X509_TRUST_OCSP_REQUEST 7
# define X509_TRUST_TSA          8
239

240
/* Keep these up to date! */
241 242
# define X509_TRUST_MIN          1
# define X509_TRUST_MAX          8
243

244
/* trust_flags values */
245 246
# define X509_TRUST_DYNAMIC      1
# define X509_TRUST_DYNAMIC_NAME 2
247 248 249

/* check_trust return codes */

250 251 252
# define X509_TRUST_TRUSTED      1
# define X509_TRUST_REJECTED     2
# define X509_TRUST_UNTRUSTED    3
253

254 255
/* Flags for X509_print_ex() */

256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
# define X509_FLAG_COMPAT                0
# define X509_FLAG_NO_HEADER             1L
# define X509_FLAG_NO_VERSION            (1L << 1)
# define X509_FLAG_NO_SERIAL             (1L << 2)
# define X509_FLAG_NO_SIGNAME            (1L << 3)
# define X509_FLAG_NO_ISSUER             (1L << 4)
# define X509_FLAG_NO_VALIDITY           (1L << 5)
# define X509_FLAG_NO_SUBJECT            (1L << 6)
# define X509_FLAG_NO_PUBKEY             (1L << 7)
# define X509_FLAG_NO_EXTENSIONS         (1L << 8)
# define X509_FLAG_NO_SIGDUMP            (1L << 9)
# define X509_FLAG_NO_AUX                (1L << 10)
# define X509_FLAG_NO_ATTRIBUTES         (1L << 11)
# define X509_FLAG_NO_IDS                (1L << 12)

/* Flags specific to X509_NAME_print_ex() */
D
 
Dr. Stephen Henson 已提交
272 273 274

/* The field separator information */

275
# define XN_FLAG_SEP_MASK        (0xf << 16)
D
 
Dr. Stephen Henson 已提交
276

277 278 279 280 281 282
# define XN_FLAG_COMPAT          0/* Traditional SSLeay: use old
                                   * X509_NAME_print */
# define XN_FLAG_SEP_COMMA_PLUS  (1 << 16)/* RFC2253 ,+ */
# define XN_FLAG_SEP_CPLUS_SPC   (2 << 16)/* ,+ spaced: more readable */
# define XN_FLAG_SEP_SPLUS_SPC   (3 << 16)/* ;+ spaced */
# define XN_FLAG_SEP_MULTILINE   (4 << 16)/* One line per field */
D
 
Dr. Stephen Henson 已提交
283

284
# define XN_FLAG_DN_REV          (1 << 20)/* Reverse DN order */
D
 
Dr. Stephen Henson 已提交
285 286 287

/* How the field name is shown */

288
# define XN_FLAG_FN_MASK         (0x3 << 21)
D
 
Dr. Stephen Henson 已提交
289

290 291 292 293
# define XN_FLAG_FN_SN           0/* Object short name */
# define XN_FLAG_FN_LN           (1 << 21)/* Object long name */
# define XN_FLAG_FN_OID          (2 << 21)/* Always use OIDs */
# define XN_FLAG_FN_NONE         (3 << 21)/* No field names */
D
 
Dr. Stephen Henson 已提交
294

295
# define XN_FLAG_SPC_EQ          (1 << 23)/* Put spaces round '=' */
D
 
Dr. Stephen Henson 已提交
296

297 298 299
/*
 * This determines if we dump fields we don't recognise: RFC2253 requires
 * this.
D
 
Dr. Stephen Henson 已提交
300 301
 */

302
# define XN_FLAG_DUMP_UNKNOWN_FIELDS (1 << 24)
D
 
Dr. Stephen Henson 已提交
303

304 305
# define XN_FLAG_FN_ALIGN        (1 << 25)/* Align field names to 20
                                           * characters */
D
 
Dr. Stephen Henson 已提交
306

D
 
Dr. Stephen Henson 已提交
307 308
/* Complete set of RFC2253 flags */

309 310 311 312 313
# define XN_FLAG_RFC2253 (ASN1_STRFLGS_RFC2253 | \
                        XN_FLAG_SEP_COMMA_PLUS | \
                        XN_FLAG_DN_REV | \
                        XN_FLAG_FN_SN | \
                        XN_FLAG_DUMP_UNKNOWN_FIELDS)
D
 
Dr. Stephen Henson 已提交
314 315 316

/* readable oneline form */

317 318 319 320 321
# define XN_FLAG_ONELINE (ASN1_STRFLGS_RFC2253 | \
                        ASN1_STRFLGS_ESC_QUOTE | \
                        XN_FLAG_SEP_CPLUS_SPC | \
                        XN_FLAG_SPC_EQ | \
                        XN_FLAG_FN_SN)
D
 
Dr. Stephen Henson 已提交
322 323 324

/* readable multiline form */

325 326 327 328 329 330 331
# define XN_FLAG_MULTILINE (ASN1_STRFLGS_ESC_CTRL | \
                        ASN1_STRFLGS_ESC_MSB | \
                        XN_FLAG_SEP_MULTILINE | \
                        XN_FLAG_SPC_EQ | \
                        XN_FLAG_FN_LN | \
                        XN_FLAG_FN_ALIGN)

B
Ben Laurie 已提交
332 333
DECLARE_STACK_OF(X509_REVOKED)

D
Dr. Stephen Henson 已提交
334
typedef struct X509_crl_info_st X509_CRL_INFO;
335

B
stack.  
Ben Laurie 已提交
336 337
DECLARE_STACK_OF(X509_CRL)

338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
typedef struct private_key_st {
    int version;
    /* The PKCS#8 data types */
    X509_ALGOR *enc_algor;
    ASN1_OCTET_STRING *enc_pkey; /* encrypted pub key */
    /* When decrypted, the following will not be NULL */
    EVP_PKEY *dec_pkey;
    /* used to encrypt and decrypt */
    int key_length;
    char *key_data;
    int key_free;               /* true if we should auto free key_data */
    /* expanded version of 'enc_algor' */
    EVP_CIPHER_INFO cipher;
    int references;
} X509_PKEY;

typedef struct X509_info_st {
    X509 *x509;
    X509_CRL *crl;
    X509_PKEY *x_pkey;
    EVP_CIPHER_INFO enc_cipher;
    int enc_len;
    char *enc_data;
    int references;
} X509_INFO;
363 364

DECLARE_STACK_OF(X509_INFO)
365

366 367 368 369
/*
 * The next 2 structures and their 8 routines were sent to me by Pat Richard
 * <patr@x509.com> and are used to manipulate Netscapes spki structures -
 * useful if you are writing a CA web page
370
 */
371 372 373 374 375 376 377
typedef struct Netscape_spkac_st {
    X509_PUBKEY *pubkey;
    ASN1_IA5STRING *challenge;  /* challenge sent in atlas >= PR2 */
} NETSCAPE_SPKAC;

typedef struct Netscape_spki_st {
    NETSCAPE_SPKAC *spkac;      /* signed public key and challenge */
378
    X509_ALGOR sig_algor;
379 380
    ASN1_BIT_STRING *signature;
} NETSCAPE_SPKI;
381

382
/* Netscape certificate sequence structure */
383 384 385 386
typedef struct Netscape_certificate_sequence {
    ASN1_OBJECT *type;
    STACK_OF(X509) *certs;
} NETSCAPE_CERT_SEQUENCE;
387

388
/*- Unused (and iv length is wrong)
389
typedef struct CBCParameter_st
390 391 392
        {
        unsigned char iv[8];
        } CBC_PARAM;
393
*/
394

395 396 397
/* Password based encryption structure */

typedef struct PBEPARAM_st {
398 399
    ASN1_OCTET_STRING *salt;
    ASN1_INTEGER *iter;
400 401
} PBEPARAM;

402 403 404
/* Password based encryption V2 structures */

typedef struct PBE2PARAM_st {
405 406
    X509_ALGOR *keyfunc;
    X509_ALGOR *encryption;
407 408 409
} PBE2PARAM;

typedef struct PBKDF2PARAM_st {
410
/* Usually OCTET STRING but could be anything */
411 412 413 414
    ASN1_TYPE *salt;
    ASN1_INTEGER *iter;
    ASN1_INTEGER *keylength;
    X509_ALGOR *prf;
415 416
} PBKDF2PARAM;

417 418
/* PKCS#8 private key info structure */

419 420 421 422 423 424 425 426 427 428 429 430 431 432
struct pkcs8_priv_key_info_st {
    /* Flag for various broken formats */
    int broken;
# define PKCS8_OK                0
# define PKCS8_NO_OCTET          1
# define PKCS8_EMBEDDED_PARAM    2
# define PKCS8_NS_DB             3
# define PKCS8_NEG_PRIVKEY       4
    ASN1_INTEGER *version;
    X509_ALGOR *pkeyalg;
    /* Should be OCTET STRING but some are broken */
    ASN1_TYPE *pkey;
    STACK_OF(X509_ATTRIBUTE) *attributes;
};
433

434 435 436 437
#ifdef  __cplusplus
}
#endif

438 439
# include <openssl/x509_vfy.h>
# include <openssl/pkcs7.h>
440

441 442 443 444
#ifdef  __cplusplus
extern "C" {
#endif

445 446 447 448 449 450 451
# define X509_EXT_PACK_UNKNOWN   1
# define X509_EXT_PACK_STRING    2

# define         X509_extract_key(x)     X509_get_pubkey(x)/*****/
# define         X509_REQ_extract_key(a) X509_REQ_get_pubkey(a)
# define         X509_name_cmp(a,b)      X509_NAME_cmp((a),(b))

452
void X509_CRL_set_default_method(const X509_CRL_METHOD *meth);
453 454 455 456 457 458 459 460
X509_CRL_METHOD *X509_CRL_METHOD_new(int (*crl_init) (X509_CRL *crl),
                                     int (*crl_free) (X509_CRL *crl),
                                     int (*crl_lookup) (X509_CRL *crl,
                                                        X509_REVOKED **ret,
                                                        ASN1_INTEGER *ser,
                                                        X509_NAME *issuer),
                                     int (*crl_verify) (X509_CRL *crl,
                                                        EVP_PKEY *pk));
461 462 463 464 465
void X509_CRL_METHOD_free(X509_CRL_METHOD *m);

void X509_CRL_set_meth_data(X509_CRL *crl, void *dat);
void *X509_CRL_get_meth_data(X509_CRL *crl);

B
Bodo Möller 已提交
466 467
const char *X509_verify_cert_error_string(long n);

468 469 470 471 472 473
int X509_verify(X509 *a, EVP_PKEY *r);

int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r);
int X509_CRL_verify(X509_CRL *a, EVP_PKEY *r);
int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r);

474 475
NETSCAPE_SPKI *NETSCAPE_SPKI_b64_decode(const char *str, int len);
char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *x);
476 477 478 479 480
EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x);
int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey);

int NETSCAPE_SPKI_print(BIO *out, NETSCAPE_SPKI *spki);

481 482
int X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent);
int X509_signature_print(BIO *bp, X509_ALGOR *alg, ASN1_STRING *sig);
483

B
Ben Laurie 已提交
484
int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
485
int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx);
486
int X509_http_nbio(OCSP_REQ_CTX *rctx, X509 **pcert);
B
Ben Laurie 已提交
487
int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md);
488
int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx);
B
Ben Laurie 已提交
489
int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md);
490
int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx);
491
int X509_CRL_http_nbio(OCSP_REQ_CTX *rctx, X509_CRL **pcrl);
B
Ben Laurie 已提交
492
int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md);
493

494 495 496 497 498 499 500 501 502 503 504 505
int X509_pubkey_digest(const X509 *data, const EVP_MD *type,
                       unsigned char *md, unsigned int *len);
int X509_digest(const X509 *data, const EVP_MD *type,
                unsigned char *md, unsigned int *len);
int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type,
                    unsigned char *md, unsigned int *len);
int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type,
                    unsigned char *md, unsigned int *len);
int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type,
                     unsigned char *md, unsigned int *len);

# ifndef OPENSSL_NO_STDIO
506
X509 *d2i_X509_fp(FILE *fp, X509 **x509);
507 508 509 510 511 512 513 514 515 516 517 518 519 520
int i2d_X509_fp(FILE *fp, X509 *x509);
X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl);
int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl);
X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req);
int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req);
#  ifndef OPENSSL_NO_RSA
RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa);
int i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa);
RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa);
int i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa);
RSA *d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa);
int i2d_RSA_PUBKEY_fp(FILE *fp, RSA *rsa);
#  endif
#  ifndef OPENSSL_NO_DSA
521 522
DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa);
int i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa);
523
DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa);
524
int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa);
525 526
#  endif
#  ifndef OPENSSL_NO_EC
527
EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey);
528
int i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey);
529
EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey);
530 531 532 533
int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey);
#  endif
X509_SIG *d2i_PKCS8_fp(FILE *fp, X509_SIG **p8);
int i2d_PKCS8_fp(FILE *fp, X509_SIG *p8);
534
PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,
535 536
                                                PKCS8_PRIV_KEY_INFO **p8inf);
int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf);
537
int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key);
538
int i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey);
539
EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a);
540 541
int i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey);
EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a);
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
# endif

X509 *d2i_X509_bio(BIO *bp, X509 **x509);
int i2d_X509_bio(BIO *bp, X509 *x509);
X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl);
int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl);
X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req);
int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req);
#  ifndef OPENSSL_NO_RSA
RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa);
int i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa);
RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa);
int i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa);
RSA *d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa);
int i2d_RSA_PUBKEY_bio(BIO *bp, RSA *rsa);
#  endif
#  ifndef OPENSSL_NO_DSA
559 560
DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa);
int i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa);
561
DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa);
562
int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa);
563 564
#  endif
#  ifndef OPENSSL_NO_EC
565
EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey);
566
int i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *eckey);
567
EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey);
568 569 570 571
int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey);
#  endif
X509_SIG *d2i_PKCS8_bio(BIO *bp, X509_SIG **p8);
int i2d_PKCS8_bio(BIO *bp, X509_SIG *p8);
572
PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,
573 574
                                                 PKCS8_PRIV_KEY_INFO **p8inf);
int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf);
575
int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key);
576
int i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey);
577
EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a);
578 579
int i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey);
EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a);
580 581

X509 *X509_dup(X509 *x509);
582
X509_ATTRIBUTE *X509_ATTRIBUTE_dup(X509_ATTRIBUTE *xa);
583 584
X509_EXTENSION *X509_EXTENSION_dup(X509_EXTENSION *ex);
X509_CRL *X509_CRL_dup(X509_CRL *crl);
585
X509_REVOKED *X509_REVOKED_dup(X509_REVOKED *rev);
586
X509_REQ *X509_REQ_dup(X509_REQ *req);
587
X509_ALGOR *X509_ALGOR_dup(X509_ALGOR *xn);
588 589
int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype,
                    void *pval);
590
void X509_ALGOR_get0(ASN1_OBJECT **paobj, int *pptype, void **ppval,
591
                     X509_ALGOR *algor);
592
void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md);
593
int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b);
594

595 596 597
X509_NAME *X509_NAME_dup(X509_NAME *xn);
X509_NAME_ENTRY *X509_NAME_ENTRY_dup(X509_NAME_ENTRY *ne);

598 599 600 601 602 603
int X509_cmp_time(const ASN1_TIME *s, time_t *t);
int X509_cmp_current_time(const ASN1_TIME *s);
ASN1_TIME *X509_time_adj(ASN1_TIME *s, long adj, time_t *t);
ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s,
                            int offset_day, long offset_sec, time_t *t);
ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj);
604

605 606 607 608 609 610
const char *X509_get_default_cert_area(void);
const char *X509_get_default_cert_dir(void);
const char *X509_get_default_cert_file(void);
const char *X509_get_default_cert_dir_env(void);
const char *X509_get_default_cert_file_env(void);
const char *X509_get_default_private_dir(void);
611

612 613
X509_REQ *X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
X509 *X509_REQ_to_X509(X509_REQ *r, int days, EVP_PKEY *pkey);
614

D
 
Dr. Stephen Henson 已提交
615
DECLARE_ASN1_FUNCTIONS(X509_ALGOR)
D
Dr. Stephen Henson 已提交
616
DECLARE_ASN1_ENCODE_FUNCTIONS(X509_ALGORS, X509_ALGORS, X509_ALGORS)
D
 
Dr. Stephen Henson 已提交
617
DECLARE_ASN1_FUNCTIONS(X509_VAL)
618

D
 
Dr. Stephen Henson 已提交
619
DECLARE_ASN1_FUNCTIONS(X509_PUBKEY)
620

621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey);
EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key);
int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain);
int i2d_PUBKEY(EVP_PKEY *a, unsigned char **pp);
EVP_PKEY *d2i_PUBKEY(EVP_PKEY **a, const unsigned char **pp, long length);
# ifndef OPENSSL_NO_RSA
int i2d_RSA_PUBKEY(RSA *a, unsigned char **pp);
RSA *d2i_RSA_PUBKEY(RSA **a, const unsigned char **pp, long length);
# endif
# ifndef OPENSSL_NO_DSA
int i2d_DSA_PUBKEY(DSA *a, unsigned char **pp);
DSA *d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp, long length);
# endif
# ifndef OPENSSL_NO_EC
int i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp);
EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length);
# endif
638

D
 
Dr. Stephen Henson 已提交
639 640 641
DECLARE_ASN1_FUNCTIONS(X509_SIG)
DECLARE_ASN1_FUNCTIONS(X509_REQ_INFO)
DECLARE_ASN1_FUNCTIONS(X509_REQ)
642

D
 
Dr. Stephen Henson 已提交
643
DECLARE_ASN1_FUNCTIONS(X509_ATTRIBUTE)
644
X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, void *value);
645

D
 
Dr. Stephen Henson 已提交
646
DECLARE_ASN1_FUNCTIONS(X509_EXTENSION)
647
DECLARE_ASN1_ENCODE_FUNCTIONS(X509_EXTENSIONS, X509_EXTENSIONS, X509_EXTENSIONS)
648

D
 
Dr. Stephen Henson 已提交
649
DECLARE_ASN1_FUNCTIONS(X509_NAME_ENTRY)
650

D
 
Dr. Stephen Henson 已提交
651
DECLARE_ASN1_FUNCTIONS(X509_NAME)
652

653
int X509_NAME_set(X509_NAME **xn, X509_NAME *name);
654

D
 
Dr. Stephen Henson 已提交
655
DECLARE_ASN1_FUNCTIONS(X509_CINF)
656

D
 
Dr. Stephen Henson 已提交
657 658
DECLARE_ASN1_FUNCTIONS(X509)
DECLARE_ASN1_FUNCTIONS(X509_CERT_AUX)
659

D
 
Dr. Stephen Henson 已提交
660
int X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
661
                          CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
D
 
Dr. Stephen Henson 已提交
662 663
int X509_set_ex_data(X509 *r, int idx, void *arg);
void *X509_get_ex_data(X509 *r, int idx);
664 665
int i2d_X509_AUX(X509 *a, unsigned char **pp);
X509 *d2i_X509_AUX(X509 **a, const unsigned char **pp, long length);
666

E
Emilia Kasper 已提交
667 668
int i2d_re_X509_tbs(X509 *x, unsigned char **pp);

669
void X509_get0_signature(ASN1_BIT_STRING **psig, X509_ALGOR **palg, X509 *x);
670 671
int X509_get_signature_nid(const X509 *x);

672
int X509_alias_set1(X509 *x, unsigned char *name, int len);
673
int X509_keyid_set1(X509 *x, unsigned char *id, int len);
674 675 676 677
unsigned char *X509_alias_get0(X509 *x, int *len);
unsigned char *X509_keyid_get0(X509 *x, int *len);
int (*X509_TRUST_set_default(int (*trust) (int, X509 *, int))) (int, X509 *,
                                                                int);
D
 
Dr. Stephen Henson 已提交
678
int X509_TRUST_set(int *t, int trust);
679 680
int X509_add1_trust_object(X509 *x, ASN1_OBJECT *obj);
int X509_add1_reject_object(X509 *x, ASN1_OBJECT *obj);
681 682
void X509_trust_clear(X509 *x);
void X509_reject_clear(X509 *x);
683

D
 
Dr. Stephen Henson 已提交
684 685 686
DECLARE_ASN1_FUNCTIONS(X509_REVOKED)
DECLARE_ASN1_FUNCTIONS(X509_CRL_INFO)
DECLARE_ASN1_FUNCTIONS(X509_CRL)
687

D
 
Dr. Stephen Henson 已提交
688
int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev);
689
int X509_CRL_get0_by_serial(X509_CRL *crl,
690
                            X509_REVOKED **ret, ASN1_INTEGER *serial);
691
int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x);
692

693 694
X509_PKEY *X509_PKEY_new(void);
void X509_PKEY_free(X509_PKEY *a);
695

D
 
Dr. Stephen Henson 已提交
696 697 698
DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKI)
DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKAC)
DECLARE_ASN1_FUNCTIONS(NETSCAPE_CERT_SEQUENCE)
699

700 701 702
X509_INFO *X509_INFO_new(void);
void X509_INFO_free(X509_INFO *a);
char *X509_NAME_oneline(X509_NAME *a, char *buf, int size);
703

B
Ben Laurie 已提交
704
int ASN1_verify(i2d_of_void *i2d, X509_ALGOR *algor1,
705
                ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey);
706

707 708
int ASN1_digest(i2d_of_void *i2d, const EVP_MD *type, char *data,
                unsigned char *md, unsigned int *len);
709

B
Ben Laurie 已提交
710
int ASN1_sign(i2d_of_void *i2d, X509_ALGOR *algor1,
711 712
              X509_ALGOR *algor2, ASN1_BIT_STRING *signature,
              char *data, EVP_PKEY *pkey, const EVP_MD *type);
713

714 715
int ASN1_item_digest(const ASN1_ITEM *it, const EVP_MD *type, void *data,
                     unsigned char *md, unsigned int *len);
716 717

int ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *algor1,
718 719 720 721 722 723 724 725 726
                     ASN1_BIT_STRING *signature, void *data, EVP_PKEY *pkey);

int ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1,
                   X509_ALGOR *algor2, ASN1_BIT_STRING *signature, void *data,
                   EVP_PKEY *pkey, const EVP_MD *type);
int ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1,
                       X509_ALGOR *algor2, ASN1_BIT_STRING *signature,
                       void *asn, EVP_MD_CTX *ctx);

727
long X509_get_version(X509 *x);
728 729 730 731 732 733 734
int X509_set_version(X509 *x, long version);
int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial);
ASN1_INTEGER *X509_get_serialNumber(X509 *x);
int X509_set_issuer_name(X509 *x, X509_NAME *name);
X509_NAME *X509_get_issuer_name(X509 *a);
int X509_set_subject_name(X509 *x, X509_NAME *name);
X509_NAME *X509_get_subject_name(X509 *a);
735
ASN1_TIME * X509_get_notBefore(X509 *x);
736
int X509_set_notBefore(X509 *x, const ASN1_TIME *tm);
737
ASN1_TIME *X509_get_notAfter(X509 *x);
738 739
int X509_set_notAfter(X509 *x, const ASN1_TIME *tm);
int X509_set_pubkey(X509 *x, EVP_PKEY *pkey);
D
Dr. Stephen Henson 已提交
740
void X509_up_ref(X509 *x);
741 742 743 744 745 746 747
int X509_get_signature_type(const X509 *x);
/*
 * This one is only used so that a binary form can output, as in
 * i2d_X509_NAME(X509_get_X509_PUBKEY(x),&buf)
 */
X509_PUBKEY *X509_get_X509_PUBKEY(const X509 *x);

748 749 750 751
EVP_PKEY *X509_get_pubkey(X509 *x);
ASN1_BIT_STRING *X509_get0_pubkey_bitstr(const X509 *x);
int X509_certificate_type(X509 *x, EVP_PKEY *pubkey /* optional */ );

D
Dr. Stephen Henson 已提交
752
long X509_REQ_get_version(X509_REQ *req);
753
int X509_REQ_set_version(X509_REQ *x, long version);
D
Dr. Stephen Henson 已提交
754
X509_NAME *X509_REQ_get_subject_name(X509_REQ *req);
755
int X509_REQ_set_subject_name(X509_REQ *req, X509_NAME *name);
756 757 758 759
void X509_REQ_get0_signature(ASN1_BIT_STRING **psig, X509_ALGOR **palg,
                             X509_REQ *req);
int X509_REQ_get_signature_nid(const X509_REQ *req);
int i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp);
760 761
int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey);
EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *req);
762
X509_PUBKEY *X509_REQ_get_X509_PUBKEY(X509_REQ *req);
763 764 765
int X509_REQ_extension_nid(int nid);
int *X509_REQ_get_extension_nids(void);
void X509_REQ_set_extension_nids(int *nids);
766
STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req);
767
int X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts,
768
                                int nid);
769
int X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts);
770
int X509_REQ_get_attr_count(const X509_REQ *req);
771
int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos);
772
int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, ASN1_OBJECT *obj,
773
                             int lastpos);
774 775
X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc);
X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc);
776 777
int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr);
int X509_REQ_add1_attr_by_OBJ(X509_REQ *req,
778 779
                              const ASN1_OBJECT *obj, int type,
                              const unsigned char *bytes, int len);
780
int X509_REQ_add1_attr_by_NID(X509_REQ *req,
781 782
                              int nid, int type,
                              const unsigned char *bytes, int len);
783
int X509_REQ_add1_attr_by_txt(X509_REQ *req,
784 785
                              const char *attrname, int type,
                              const unsigned char *bytes, int len);
786

D
 
Dr. Stephen Henson 已提交
787 788
int X509_CRL_set_version(X509_CRL *x, long version);
int X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name);
N
Nils Larsch 已提交
789 790
int X509_CRL_set_lastUpdate(X509_CRL *x, const ASN1_TIME *tm);
int X509_CRL_set_nextUpdate(X509_CRL *x, const ASN1_TIME *tm);
D
 
Dr. Stephen Henson 已提交
791
int X509_CRL_sort(X509_CRL *crl);
792
void X509_CRL_up_ref(X509_CRL *crl);
D
 
Dr. Stephen Henson 已提交
793

D
Dr. Stephen Henson 已提交
794 795 796 797
long X509_CRL_get_version(X509_CRL *crl);
ASN1_TIME *X509_CRL_get_lastUpdate(X509_CRL *crl);
ASN1_TIME *X509_CRL_get_nextUpdate(X509_CRL *crl);
X509_NAME *X509_CRL_get_issuer(X509_CRL *crl);
798
STACK_OF(X509_EXTENSION) *X509_CRL_get0_extensions(X509_CRL *crl);
D
Dr. Stephen Henson 已提交
799 800
STACK_OF(X509_REVOKED) *X509_CRL_get_REVOKED(X509_CRL *crl);
void X509_CRL_get0_signature(ASN1_BIT_STRING **psig, X509_ALGOR **palg,
801
                             X509_CRL *crl);
802 803
int X509_CRL_get_signature_nid(const X509_CRL *crl);
int i2d_re_X509_CRL_tbs(X509_CRL *req, unsigned char **pp);
D
Dr. Stephen Henson 已提交
804

805
ASN1_INTEGER *X509_REVOKED_get0_serialNumber(X509_REVOKED *x);
D
 
Dr. Stephen Henson 已提交
806
int X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial);
807
ASN1_TIME *X509_REVOKED_get0_revocationDate(X509_REVOKED *x);
D
 
Dr. Stephen Henson 已提交
808
int X509_REVOKED_set_revocationDate(X509_REVOKED *r, ASN1_TIME *tm);
809
STACK_OF(X509_EXTENSION) *X509_REVOKED_get0_extensions(X509_REVOKED *r);
D
 
Dr. Stephen Henson 已提交
810

811
X509_CRL *X509_CRL_diff(X509_CRL *base, X509_CRL *newer,
812
                        EVP_PKEY *skey, const EVP_MD *md, unsigned int flags);
813

814
int X509_REQ_check_private_key(X509_REQ *x509, EVP_PKEY *pkey);
815

816 817 818 819 820
int X509_check_private_key(X509 *x509, EVP_PKEY *pkey);
int X509_chain_check_suiteb(int *perror_depth,
                            X509 *x, STACK_OF(X509) *chain,
                            unsigned long flags);
int X509_CRL_check_suiteb(X509_CRL *crl, EVP_PKEY *pk, unsigned long flags);
821
STACK_OF(X509) *X509_chain_up_ref(STACK_OF(X509) *chain);
822

823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878
int X509_issuer_and_serial_cmp(const X509 *a, const X509 *b);
unsigned long X509_issuer_and_serial_hash(X509 *a);

int X509_issuer_name_cmp(const X509 *a, const X509 *b);
unsigned long X509_issuer_name_hash(X509 *a);

int X509_subject_name_cmp(const X509 *a, const X509 *b);
unsigned long X509_subject_name_hash(X509 *x);

# ifndef OPENSSL_NO_MD5
unsigned long X509_issuer_name_hash_old(X509 *a);
unsigned long X509_subject_name_hash_old(X509 *x);
# endif

int X509_cmp(const X509 *a, const X509 *b);
int X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b);
unsigned long X509_NAME_hash(X509_NAME *x);
unsigned long X509_NAME_hash_old(X509_NAME *x);

int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b);
int X509_CRL_match(const X509_CRL *a, const X509_CRL *b);
# ifndef OPENSSL_NO_STDIO
int X509_print_ex_fp(FILE *bp, X509 *x, unsigned long nmflag,
                     unsigned long cflag);
int X509_print_fp(FILE *bp, X509 *x);
int X509_CRL_print_fp(FILE *bp, X509_CRL *x);
int X509_REQ_print_fp(FILE *bp, X509_REQ *req);
int X509_NAME_print_ex_fp(FILE *fp, X509_NAME *nm, int indent,
                          unsigned long flags);
# endif

int X509_NAME_print(BIO *bp, X509_NAME *name, int obase);
int X509_NAME_print_ex(BIO *out, X509_NAME *nm, int indent,
                       unsigned long flags);
int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflag,
                  unsigned long cflag);
int X509_print(BIO *bp, X509 *x);
int X509_ocspid_print(BIO *bp, X509 *x);
int X509_CERT_AUX_print(BIO *bp, X509_CERT_AUX *x, int indent);
int X509_CRL_print(BIO *bp, X509_CRL *x);
int X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag,
                      unsigned long cflag);
int X509_REQ_print(BIO *bp, X509_REQ *req);

int X509_NAME_entry_count(X509_NAME *name);
int X509_NAME_get_text_by_NID(X509_NAME *name, int nid, char *buf, int len);
int X509_NAME_get_text_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj,
                              char *buf, int len);

/*
 * NOTE: you should be passsing -1, not 0 as lastpos.  The functions that use
 * lastpos, search after that position on.
 */
int X509_NAME_get_index_by_NID(X509_NAME *name, int nid, int lastpos);
int X509_NAME_get_index_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj,
                               int lastpos);
879 880
X509_NAME_ENTRY *X509_NAME_get_entry(X509_NAME *name, int loc);
X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc);
881 882
int X509_NAME_add_entry(X509_NAME *name, X509_NAME_ENTRY *ne,
                        int loc, int set);
883
int X509_NAME_add_entry_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj, int type,
884 885
                               unsigned char *bytes, int len, int loc,
                               int set);
886
int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
887 888
                               unsigned char *bytes, int len, int loc,
                               int set);
889
X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
890 891 892
                                               const char *field, int type,
                                               const unsigned char *bytes,
                                               int len);
893
X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid,
894 895
                                               int type, unsigned char *bytes,
                                               int len);
B
Ben Laurie 已提交
896
int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
897 898
                               const unsigned char *bytes, int len, int loc,
                               int set);
899
X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne,
900 901 902 903 904 905 906 907
                                               ASN1_OBJECT *obj, int type,
                                               const unsigned char *bytes,
                                               int len);
int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, ASN1_OBJECT *obj);
int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
                             const unsigned char *bytes, int len);
ASN1_OBJECT *X509_NAME_ENTRY_get_object(X509_NAME_ENTRY *ne);
ASN1_STRING *X509_NAME_ENTRY_get_data(X509_NAME_ENTRY *ne);
D
Dr. Stephen Henson 已提交
908
int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne);
909 910 911 912 913 914 915 916

int X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x);
int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x,
                          int nid, int lastpos);
int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *x,
                          ASN1_OBJECT *obj, int lastpos);
int X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *x,
                               int crit, int lastpos);
B
Ben Laurie 已提交
917 918 919
X509_EXTENSION *X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc);
X509_EXTENSION *X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc);
STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x,
920
                                         X509_EXTENSION *ex, int loc);
921

922 923 924 925
int X509_get_ext_count(X509 *x);
int X509_get_ext_by_NID(X509 *x, int nid, int lastpos);
int X509_get_ext_by_OBJ(X509 *x, ASN1_OBJECT *obj, int lastpos);
int X509_get_ext_by_critical(X509 *x, int crit, int lastpos);
926 927
X509_EXTENSION *X509_get_ext(X509 *x, int loc);
X509_EXTENSION *X509_delete_ext(X509 *x, int loc);
928 929 930 931 932 933 934 935 936
int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc);
void *X509_get_ext_d2i(X509 *x, int nid, int *crit, int *idx);
int X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit,
                      unsigned long flags);

int X509_CRL_get_ext_count(X509_CRL *x);
int X509_CRL_get_ext_by_NID(X509_CRL *x, int nid, int lastpos);
int X509_CRL_get_ext_by_OBJ(X509_CRL *x, ASN1_OBJECT *obj, int lastpos);
int X509_CRL_get_ext_by_critical(X509_CRL *x, int crit, int lastpos);
937 938
X509_EXTENSION *X509_CRL_get_ext(X509_CRL *x, int loc);
X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc);
939 940 941 942 943 944 945 946 947 948
int X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc);
void *X509_CRL_get_ext_d2i(X509_CRL *x, int nid, int *crit, int *idx);
int X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit,
                          unsigned long flags);

int X509_REVOKED_get_ext_count(X509_REVOKED *x);
int X509_REVOKED_get_ext_by_NID(X509_REVOKED *x, int nid, int lastpos);
int X509_REVOKED_get_ext_by_OBJ(X509_REVOKED *x, ASN1_OBJECT *obj,
                                int lastpos);
int X509_REVOKED_get_ext_by_critical(X509_REVOKED *x, int crit, int lastpos);
949 950
X509_EXTENSION *X509_REVOKED_get_ext(X509_REVOKED *x, int loc);
X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc);
951 952 953 954
int X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc);
void *X509_REVOKED_get_ext_d2i(X509_REVOKED *x, int nid, int *crit, int *idx);
int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,
                              unsigned long flags);
955 956

X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex,
957 958
                                             int nid, int crit,
                                             ASN1_OCTET_STRING *data);
959
X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex,
960 961 962 963 964 965
                                             ASN1_OBJECT *obj, int crit,
                                             ASN1_OCTET_STRING *data);
int X509_EXTENSION_set_object(X509_EXTENSION *ex, ASN1_OBJECT *obj);
int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit);
int X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data);
ASN1_OBJECT *X509_EXTENSION_get_object(X509_EXTENSION *ex);
966
ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne);
967
int X509_EXTENSION_get_critical(X509_EXTENSION *ex);
968

969 970
int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x);
int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
971 972 973
                           int lastpos);
int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
                           ASN1_OBJECT *obj, int lastpos);
974 975
X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc);
X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc);
976
STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x,
977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
                                           X509_ATTRIBUTE *attr);
STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE)
                                                  **x, const ASN1_OBJECT *obj,
                                                  int type,
                                                  const unsigned char *bytes,
                                                  int len);
STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE)
                                                  **x, int nid, int type,
                                                  const unsigned char *bytes,
                                                  int len);
STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE)
                                                  **x, const char *attrname,
                                                  int type,
                                                  const unsigned char *bytes,
                                                  int len);
void *X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, ASN1_OBJECT *obj,
                              int lastpos, int type);
994
X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
995 996
                                             int atrtype, const void *data,
                                             int len);
997
X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
998 999 1000
                                             const ASN1_OBJECT *obj,
                                             int atrtype, const void *data,
                                             int len);
1001
X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
1002 1003 1004
                                             const char *atrname, int type,
                                             const unsigned char *bytes,
                                             int len);
1005
int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj);
1006 1007 1008 1009
int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype,
                             const void *data, int len);
void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype,
                               void *data);
1010
int X509_ATTRIBUTE_count(X509_ATTRIBUTE *attr);
1011 1012
ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr);
ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx);
1013

1014
int EVP_PKEY_get_attr_count(const EVP_PKEY *key);
1015
int EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid, int lastpos);
1016
int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, ASN1_OBJECT *obj,
1017
                             int lastpos);
1018 1019 1020 1021
X509_ATTRIBUTE *EVP_PKEY_get_attr(const EVP_PKEY *key, int loc);
X509_ATTRIBUTE *EVP_PKEY_delete_attr(EVP_PKEY *key, int loc);
int EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr);
int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key,
1022 1023
                              const ASN1_OBJECT *obj, int type,
                              const unsigned char *bytes, int len);
1024
int EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key,
1025 1026
                              int nid, int type,
                              const unsigned char *bytes, int len);
1027
int EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key,
1028 1029
                              const char *attrname, int type,
                              const unsigned char *bytes, int len);
1030

1031
int X509_verify_cert(X509_STORE_CTX *ctx);
1032 1033

/* lookup a cert from a X509 STACK */
1034 1035 1036
X509 *X509_find_by_issuer_and_serial(STACK_OF(X509) *sk, X509_NAME *name,
                                     ASN1_INTEGER *serial);
X509 *X509_find_by_subject(STACK_OF(X509) *sk, X509_NAME *name);
1037

D
 
Dr. Stephen Henson 已提交
1038 1039 1040 1041
DECLARE_ASN1_FUNCTIONS(PBEPARAM)
DECLARE_ASN1_FUNCTIONS(PBE2PARAM)
DECLARE_ASN1_FUNCTIONS(PBKDF2PARAM)

D
Dr. Stephen Henson 已提交
1042
int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,
1043
                         const unsigned char *salt, int saltlen);
D
Dr. Stephen Henson 已提交
1044 1045

X509_ALGOR *PKCS5_pbe_set(int alg, int iter,
1046
                          const unsigned char *salt, int saltlen);
1047
X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter,
1048
                           unsigned char *salt, int saltlen);
1049
X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter,
1050 1051
                              unsigned char *salt, int saltlen,
                              unsigned char *aiv, int prf_nid);
1052

R
Rich Salz 已提交
1053
#ifndef OPENSSL_NO_SCRYPT
1054 1055 1056 1057
X509_ALGOR *PKCS5_pbe2_set_scrypt(const EVP_CIPHER *cipher,
                                  const unsigned char *salt, int saltlen,
                                  unsigned char *aiv, uint64_t N, uint64_t r,
                                  uint64_t p);
R
Rich Salz 已提交
1058
#endif
1059

D
Dr. Stephen Henson 已提交
1060
X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen,
1061
                             int prf_nid, int keylen);
D
Dr. Stephen Henson 已提交
1062

1063 1064
/* PKCS#8 utilities */

D
 
Dr. Stephen Henson 已提交
1065
DECLARE_ASN1_FUNCTIONS(PKCS8_PRIV_KEY_INFO)
1066 1067 1068

EVP_PKEY *EVP_PKCS82PKEY(PKCS8_PRIV_KEY_INFO *p8);
PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(EVP_PKEY *pkey);
1069
PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8_broken(EVP_PKEY *pkey, int broken);
1070 1071
PKCS8_PRIV_KEY_INFO *PKCS8_set_broken(PKCS8_PRIV_KEY_INFO *p8, int broken);

1072
int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj,
1073 1074
                    int version, int ptype, void *pval,
                    unsigned char *penc, int penclen);
1075
int PKCS8_pkey_get0(ASN1_OBJECT **ppkalg,
1076 1077
                    const unsigned char **pk, int *ppklen,
                    X509_ALGOR **pa, PKCS8_PRIV_KEY_INFO *p8);
1078 1079

int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj,
1080 1081
                           int ptype, void *pval,
                           unsigned char *penc, int penclen);
1082
int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg,
1083 1084
                           const unsigned char **pk, int *ppklen,
                           X509_ALGOR **pa, X509_PUBKEY *pub);
1085

1086 1087
int X509_check_trust(X509 *x, int id, int flags);
int X509_TRUST_get_count(void);
1088
X509_TRUST *X509_TRUST_get0(int idx);
1089
int X509_TRUST_get_by_id(int id);
1090 1091
int X509_TRUST_add(int id, int flags, int (*ck) (X509_TRUST *, X509 *, int),
                   char *name, int arg1, void *arg2);
1092
void X509_TRUST_cleanup(void);
1093
int X509_TRUST_get_flags(X509_TRUST *xp);
1094
char *X509_TRUST_get0_name(X509_TRUST *xp);
1095 1096
int X509_TRUST_get_trust(X509_TRUST *xp);

1097
/* BEGIN ERROR CODES */
1098 1099
/*
 * The following lines are auto generated by the script mkerr.pl. Any changes
1100 1101
 * made after this point may be overwritten when the script is next run.
 */
D
 
Dr. Stephen Henson 已提交
1102
void ERR_load_X509_strings(void);
1103

1104 1105 1106
/* Error codes for the X509 functions. */

/* Function codes. */
1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
# define X509_F_ADD_CERT_DIR                              100
# define X509_F_BY_FILE_CTRL                              101
# define X509_F_CHECK_POLICY                              145
# define X509_F_DIR_CTRL                                  102
# define X509_F_GET_CERT_BY_SUBJECT                       103
# define X509_F_NETSCAPE_SPKI_B64_DECODE                  129
# define X509_F_NETSCAPE_SPKI_B64_ENCODE                  130
# define X509_F_X509AT_ADD1_ATTR                          135
# define X509_F_X509V3_ADD_EXT                            104
# define X509_F_X509_ATTRIBUTE_CREATE_BY_NID              136
# define X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ              137
# define X509_F_X509_ATTRIBUTE_CREATE_BY_TXT              140
# define X509_F_X509_ATTRIBUTE_GET0_DATA                  139
# define X509_F_X509_ATTRIBUTE_SET1_DATA                  138
# define X509_F_X509_CHECK_PRIVATE_KEY                    128
# define X509_F_X509_CRL_DIFF                             105
# define X509_F_X509_CRL_PRINT_FP                         147
# define X509_F_X509_EXTENSION_CREATE_BY_NID              108
# define X509_F_X509_EXTENSION_CREATE_BY_OBJ              109
# define X509_F_X509_GET_PUBKEY_PARAMETERS                110
# define X509_F_X509_LOAD_CERT_CRL_FILE                   132
# define X509_F_X509_LOAD_CERT_FILE                       111
# define X509_F_X509_LOAD_CRL_FILE                        112
# define X509_F_X509_NAME_ADD_ENTRY                       113
# define X509_F_X509_NAME_ENTRY_CREATE_BY_NID             114
# define X509_F_X509_NAME_ENTRY_CREATE_BY_TXT             131
# define X509_F_X509_NAME_ENTRY_SET_OBJECT                115
# define X509_F_X509_NAME_ONELINE                         116
# define X509_F_X509_NAME_PRINT                           117
# define X509_F_X509_PRINT_EX_FP                          118
# define X509_F_X509_PUBKEY_GET                           119
# define X509_F_X509_PUBKEY_SET                           120
# define X509_F_X509_REQ_CHECK_PRIVATE_KEY                144
# define X509_F_X509_REQ_PRINT_EX                         121
# define X509_F_X509_REQ_PRINT_FP                         122
# define X509_F_X509_REQ_TO_X509                          123
# define X509_F_X509_STORE_ADD_CERT                       124
# define X509_F_X509_STORE_ADD_CRL                        125
# define X509_F_X509_STORE_CTX_GET1_ISSUER                146
# define X509_F_X509_STORE_CTX_INIT                       143
# define X509_F_X509_STORE_CTX_NEW                        142
# define X509_F_X509_STORE_CTX_PURPOSE_INHERIT            134
# define X509_F_X509_TO_X509_REQ                          126
# define X509_F_X509_TRUST_ADD                            133
# define X509_F_X509_TRUST_SET                            141
# define X509_F_X509_VERIFY_CERT                          127
1153 1154

/* Reason codes. */
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
# define X509_R_AKID_MISMATCH                             110
# define X509_R_BAD_X509_FILETYPE                         100
# define X509_R_BASE64_DECODE_ERROR                       118
# define X509_R_CANT_CHECK_DH_KEY                         114
# define X509_R_CERT_ALREADY_IN_HASH_TABLE                101
# define X509_R_CRL_ALREADY_DELTA                         127
# define X509_R_CRL_VERIFY_FAILURE                        131
# define X509_R_ERR_ASN1_LIB                              102
# define X509_R_IDP_MISMATCH                              128
# define X509_R_INVALID_DIRECTORY                         113
# define X509_R_INVALID_FIELD_NAME                        119
# define X509_R_INVALID_TRUST                             123
# define X509_R_ISSUER_MISMATCH                           129
# define X509_R_KEY_TYPE_MISMATCH                         115
# define X509_R_KEY_VALUES_MISMATCH                       116
# define X509_R_LOADING_CERT_DIR                          103
# define X509_R_LOADING_DEFAULTS                          104
# define X509_R_METHOD_NOT_SUPPORTED                      124
# define X509_R_NEWER_CRL_NOT_NEWER                       132
# define X509_R_NO_CERT_SET_FOR_US_TO_VERIFY              105
# define X509_R_NO_CRL_NUMBER                             130
# define X509_R_PUBLIC_KEY_DECODE_ERROR                   125
# define X509_R_PUBLIC_KEY_ENCODE_ERROR                   126
# define X509_R_SHOULD_RETRY                              106
# define X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN        107
# define X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY            108
# define X509_R_UNKNOWN_KEY_TYPE                          117
# define X509_R_UNKNOWN_NID                               109
# define X509_R_UNKNOWN_PURPOSE_ID                        121
# define X509_R_UNKNOWN_TRUST_ID                          120
# define X509_R_UNSUPPORTED_ALGORITHM                     111
# define X509_R_WRONG_LOOKUP_TYPE                         112
# define X509_R_WRONG_TYPE                                122
1188

1189 1190 1191 1192
#ifdef  __cplusplus
}
#endif
#endif