Debian Codegraph @

external/boringssl/include/openssl/x509.h

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