← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/boringssl/src/include/openssl/x509.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/boringssl/src/include/openssl/x509.h
1
 
/* crypto/x509/x509.h */
2
 
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3
 
 * All rights reserved.
4
 
 *
5
 
 * This package is an SSL implementation written
6
 
 * by Eric Young (eay@cryptsoft.com).
7
 
 * The implementation was written so as to conform with Netscapes SSL.
8
 
 * 
9
 
 * This library is free for commercial and non-commercial use as long as
10
 
 * the following conditions are aheared to.  The following conditions
11
 
 * apply to all code found in this distribution, be it the RC4, RSA,
12
 
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13
 
 * included with this distribution is covered by the same copyright terms
14
 
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15
 
 * 
16
 
 * Copyright remains Eric Young's, and as such any Copyright notices in
17
 
 * the code are not to be removed.
18
 
 * If this package is used in a product, Eric Young should be given attribution
19
 
 * as the author of the parts of the library used.
20
 
 * This can be in the form of a textual message at program startup or
21
 
 * in documentation (online or textual) provided with the package.
22
 
 * 
23
 
 * Redistribution and use in source and binary forms, with or without
24
 
 * modification, are permitted provided that the following conditions
25
 
 * are met:
26
 
 * 1. Redistributions of source code must retain the copyright
27
 
 *    notice, this list of conditions and the following disclaimer.
28
 
 * 2. Redistributions in binary form must reproduce the above copyright
29
 
 *    notice, this list of conditions and the following disclaimer in the
30
 
 *    documentation and/or other materials provided with the distribution.
31
 
 * 3. All advertising materials mentioning features or use of this software
32
 
 *    must display the following acknowledgement:
33
 
 *    "This product includes cryptographic software written by
34
 
 *     Eric Young (eay@cryptsoft.com)"
35
 
 *    The word 'cryptographic' can be left out if the rouines from the library
36
 
 *    being used are not cryptographic related :-).
37
 
 * 4. If you include any Windows specific code (or a derivative thereof) from 
38
 
 *    the apps directory (application code) you must include an acknowledgement:
39
 
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40
 
 * 
41
 
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42
 
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43
 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44
 
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45
 
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46
 
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47
 
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48
 
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49
 
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50
 
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51
 
 * SUCH DAMAGE.
52
 
 * 
53
 
 * The licence and distribution terms for any publically available version or
54
 
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
55
 
 * copied and put under another distribution licence
56
 
 * [including the GNU Public Licence.]
57
 
 */
58
 
/* ====================================================================
59
 
 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
60
 
 * ECDH support in OpenSSL originally developed by 
61
 
 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
62
 
 */
63
 
 
64
 
#ifndef HEADER_X509_H
65
 
#define HEADER_X509_H
66
 
 
67
 
#include <openssl/base.h>
68
 
 
69
 
#include <time.h>
70
 
 
71
 
#include <openssl/asn1.h>
72
 
#include <openssl/bio.h>
73
 
#include <openssl/cipher.h>
74
 
#include <openssl/dh.h>
75
 
#include <openssl/dsa.h>
76
 
#include <openssl/ecdh.h>
77
 
#include <openssl/ecdsa.h>
78
 
#include <openssl/ec.h>
79
 
#include <openssl/evp.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
 
typedef 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
 
typedef 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
 
typedef struct X509_sig_st
130
 
        {
131
 
        X509_ALGOR *algor;
132
 
        ASN1_OCTET_STRING *digest;
133
 
        } X509_SIG;
134
 
 
135
 
typedef 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
 
typedef 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
 
typedef 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
 
typedef 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
 
typedef 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
 
typedef 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
 
typedef 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
 
typedef 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
 
typedef 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
 
typedef 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
 
typedef 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
 
typedef 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
 
typedef 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 <patr@x509.com> and are used to manipulate
481
 
 * Netscapes spki structures - useful if you are writing a CA web page
482
 
 */
483
 
typedef struct Netscape_spkac_st
484
 
        {
485
 
        X509_PUBKEY *pubkey;
486
 
        ASN1_IA5STRING *challenge;      /* challenge sent in atlas >= PR2 */
487
 
        } NETSCAPE_SPKAC;
488
 
 
489
 
typedef 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
 
typedef 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
 
typedef struct PBEPARAM_st {
513
 
ASN1_OCTET_STRING *salt;
514
 
ASN1_INTEGER *iter;
515
 
} PBEPARAM;
516
 
 
517
 
/* Password based encryption V2 structures */
518
 
 
519
 
typedef struct PBE2PARAM_st {
520
 
X509_ALGOR *keyfunc;
521
 
X509_ALGOR *encryption;
522
 
} PBE2PARAM;
523
 
 
524
 
typedef 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
 
/* int X509_http_nbio(OCSP_REQ_CTX *rctx, X509 **pcert); */
623
 
OPENSSL_EXPORT int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md);
624
 
OPENSSL_EXPORT int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx);
625
 
OPENSSL_EXPORT int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md);
626
 
OPENSSL_EXPORT int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx);
627
 
/* int X509_CRL_http_nbio(OCSP_REQ_CTX *rctx, X509_CRL **pcrl); */
628
 
OPENSSL_EXPORT int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md);
629
 
 
630
 
OPENSSL_EXPORT int X509_pubkey_digest(const X509 *data,const EVP_MD *type,
631
 
                unsigned char *md, unsigned int *len);
632
 
OPENSSL_EXPORT int X509_digest(const X509 *data,const EVP_MD *type,
633
 
                unsigned char *md, unsigned int *len);
634
 
OPENSSL_EXPORT int X509_CRL_digest(const X509_CRL *data,const EVP_MD *type,
635
 
                unsigned char *md, unsigned int *len);
636
 
OPENSSL_EXPORT int X509_REQ_digest(const X509_REQ *data,const EVP_MD *type,
637
 
                unsigned char *md, unsigned int *len);
638
 
OPENSSL_EXPORT int X509_NAME_digest(const X509_NAME *data,const EVP_MD *type,
639
 
                unsigned char *md, unsigned int *len);
640
 
#endif
641
 
 
642
 
#ifndef OPENSSL_NO_FP_API
643
 
OPENSSL_EXPORT X509 *d2i_X509_fp(FILE *fp, X509 **x509);
644
 
OPENSSL_EXPORT int i2d_X509_fp(FILE *fp,X509 *x509);
645
 
OPENSSL_EXPORT X509_CRL *d2i_X509_CRL_fp(FILE *fp,X509_CRL **crl);
646
 
OPENSSL_EXPORT int i2d_X509_CRL_fp(FILE *fp,X509_CRL *crl);
647
 
OPENSSL_EXPORT X509_REQ *d2i_X509_REQ_fp(FILE *fp,X509_REQ **req);
648
 
OPENSSL_EXPORT int i2d_X509_REQ_fp(FILE *fp,X509_REQ *req);
649
 
OPENSSL_EXPORT RSA *d2i_RSAPrivateKey_fp(FILE *fp,RSA **rsa);
650
 
OPENSSL_EXPORT int i2d_RSAPrivateKey_fp(FILE *fp,RSA *rsa);
651
 
OPENSSL_EXPORT RSA *d2i_RSAPublicKey_fp(FILE *fp,RSA **rsa);
652
 
OPENSSL_EXPORT int i2d_RSAPublicKey_fp(FILE *fp,RSA *rsa);
653
 
OPENSSL_EXPORT RSA *d2i_RSA_PUBKEY_fp(FILE *fp,RSA **rsa);
654
 
OPENSSL_EXPORT int i2d_RSA_PUBKEY_fp(FILE *fp,RSA *rsa);
655
 
#ifndef OPENSSL_NO_DSA
656
 
OPENSSL_EXPORT DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa);
657
 
OPENSSL_EXPORT int i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa);
658
 
OPENSSL_EXPORT DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa);
659
 
OPENSSL_EXPORT int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa);
660
 
#endif
661
 
OPENSSL_EXPORT EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey);
662
 
OPENSSL_EXPORT int   i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey);
663
 
OPENSSL_EXPORT EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey);
664
 
OPENSSL_EXPORT int   i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey);
665
 
OPENSSL_EXPORT X509_SIG *d2i_PKCS8_fp(FILE *fp,X509_SIG **p8);
666
 
OPENSSL_EXPORT int i2d_PKCS8_fp(FILE *fp,X509_SIG *p8);
667
 
OPENSSL_EXPORT PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,
668
 
                                                PKCS8_PRIV_KEY_INFO **p8inf);
669
 
OPENSSL_EXPORT int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,PKCS8_PRIV_KEY_INFO *p8inf);
670
 
OPENSSL_EXPORT int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key);
671
 
OPENSSL_EXPORT int i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey);
672
 
OPENSSL_EXPORT EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a);
673
 
OPENSSL_EXPORT int i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey);
674
 
OPENSSL_EXPORT EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a);
675
 
#endif
676
 
 
677
 
OPENSSL_EXPORT X509 *d2i_X509_bio(BIO *bp,X509 **x509);
678
 
OPENSSL_EXPORT int i2d_X509_bio(BIO *bp,X509 *x509);
679
 
OPENSSL_EXPORT X509_CRL *d2i_X509_CRL_bio(BIO *bp,X509_CRL **crl);
680
 
OPENSSL_EXPORT int i2d_X509_CRL_bio(BIO *bp,X509_CRL *crl);
681
 
OPENSSL_EXPORT X509_REQ *d2i_X509_REQ_bio(BIO *bp,X509_REQ **req);
682
 
OPENSSL_EXPORT int i2d_X509_REQ_bio(BIO *bp,X509_REQ *req);
683
 
OPENSSL_EXPORT RSA *d2i_RSAPrivateKey_bio(BIO *bp,RSA **rsa);
684
 
OPENSSL_EXPORT int i2d_RSAPrivateKey_bio(BIO *bp,RSA *rsa);
685
 
OPENSSL_EXPORT RSA *d2i_RSAPublicKey_bio(BIO *bp,RSA **rsa);
686
 
OPENSSL_EXPORT int i2d_RSAPublicKey_bio(BIO *bp,RSA *rsa);
687
 
OPENSSL_EXPORT RSA *d2i_RSA_PUBKEY_bio(BIO *bp,RSA **rsa);
688
 
OPENSSL_EXPORT int i2d_RSA_PUBKEY_bio(BIO *bp,RSA *rsa);
689
 
#ifndef OPENSSL_NO_DSA
690
 
OPENSSL_EXPORT DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa);
691
 
OPENSSL_EXPORT int i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa);
692
 
OPENSSL_EXPORT DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa);
693
 
OPENSSL_EXPORT int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa);
694
 
#endif
695
 
OPENSSL_EXPORT EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey);
696
 
OPENSSL_EXPORT int   i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *eckey);
697
 
OPENSSL_EXPORT EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey);
698
 
OPENSSL_EXPORT int   i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey);
699
 
OPENSSL_EXPORT X509_SIG *d2i_PKCS8_bio(BIO *bp,X509_SIG **p8);
700
 
OPENSSL_EXPORT int i2d_PKCS8_bio(BIO *bp,X509_SIG *p8);
701
 
OPENSSL_EXPORT PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,
702
 
                                                PKCS8_PRIV_KEY_INFO **p8inf);
703
 
OPENSSL_EXPORT int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,PKCS8_PRIV_KEY_INFO *p8inf);
704
 
OPENSSL_EXPORT int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key);
705
 
OPENSSL_EXPORT int i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey);
706
 
OPENSSL_EXPORT EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a);
707
 
OPENSSL_EXPORT int i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey);
708
 
OPENSSL_EXPORT EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a);
709
 
 
710
 
OPENSSL_EXPORT X509 *X509_dup(X509 *x509);
711
 
OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_dup(X509_ATTRIBUTE *xa);
712
 
OPENSSL_EXPORT X509_EXTENSION *X509_EXTENSION_dup(X509_EXTENSION *ex);
713
 
OPENSSL_EXPORT X509_CRL *X509_CRL_dup(X509_CRL *crl);
714
 
OPENSSL_EXPORT X509_REVOKED *X509_REVOKED_dup(X509_REVOKED *rev);
715
 
OPENSSL_EXPORT X509_REQ *X509_REQ_dup(X509_REQ *req);
716
 
OPENSSL_EXPORT X509_ALGOR *X509_ALGOR_dup(X509_ALGOR *xn);
717
 
OPENSSL_EXPORT int X509_ALGOR_set0(X509_ALGOR *alg, const ASN1_OBJECT *aobj, int ptype, void *pval);
718
 
OPENSSL_EXPORT void X509_ALGOR_get0(ASN1_OBJECT **paobj, int *pptype, void **ppval,
719
 
                                                X509_ALGOR *algor);
720
 
OPENSSL_EXPORT void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md);
721
 
OPENSSL_EXPORT int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b);
722
 
 
723
 
OPENSSL_EXPORT X509_NAME *X509_NAME_dup(X509_NAME *xn);
724
 
OPENSSL_EXPORT X509_NAME_ENTRY *X509_NAME_ENTRY_dup(X509_NAME_ENTRY *ne);
725
 
 
726
 
OPENSSL_EXPORT int              X509_cmp_time(const ASN1_TIME *s, time_t *t);
727
 
OPENSSL_EXPORT int              X509_cmp_current_time(const ASN1_TIME *s);
728
 
OPENSSL_EXPORT ASN1_TIME *      X509_time_adj(ASN1_TIME *s, long adj, time_t *t);
729
 
OPENSSL_EXPORT ASN1_TIME *      X509_time_adj_ex(ASN1_TIME *s, int offset_day, long offset_sec, time_t *t);
730
 
OPENSSL_EXPORT ASN1_TIME *      X509_gmtime_adj(ASN1_TIME *s, long adj);
731
 
 
732
 
OPENSSL_EXPORT const char *     X509_get_default_cert_area(void );
733
 
OPENSSL_EXPORT const char *     X509_get_default_cert_dir(void );
734
 
OPENSSL_EXPORT const char *     X509_get_default_cert_file(void );
735
 
OPENSSL_EXPORT const char *     X509_get_default_cert_dir_env(void );
736
 
OPENSSL_EXPORT const char *     X509_get_default_cert_file_env(void );
737
 
OPENSSL_EXPORT const char *     X509_get_default_private_dir(void );
738
 
 
739
 
OPENSSL_EXPORT X509_REQ *       X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
740
 
OPENSSL_EXPORT X509 *           X509_REQ_to_X509(X509_REQ *r, int days,EVP_PKEY *pkey);
741
 
 
742
 
DECLARE_ASN1_ENCODE_FUNCTIONS(X509_ALGORS, X509_ALGORS, X509_ALGORS)
743
 
DECLARE_ASN1_FUNCTIONS(X509_VAL)
744
 
 
745
 
DECLARE_ASN1_FUNCTIONS(X509_PUBKEY)
746
 
 
747
 
OPENSSL_EXPORT int              X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey);
748
 
OPENSSL_EXPORT EVP_PKEY *       X509_PUBKEY_get(X509_PUBKEY *key);
749
 
OPENSSL_EXPORT int              i2d_PUBKEY(const EVP_PKEY *a,unsigned char **pp);
750
 
OPENSSL_EXPORT EVP_PKEY *       d2i_PUBKEY(EVP_PKEY **a,const unsigned char **pp,
751
 
                        long length);
752
 
OPENSSL_EXPORT int              i2d_RSA_PUBKEY(const RSA *a,unsigned char **pp);
753
 
OPENSSL_EXPORT RSA *            d2i_RSA_PUBKEY(RSA **a,const unsigned char **pp,
754
 
                        long length);
755
 
#ifndef OPENSSL_NO_DSA
756
 
OPENSSL_EXPORT int              i2d_DSA_PUBKEY(const DSA *a,unsigned char **pp);
757
 
OPENSSL_EXPORT DSA *            d2i_DSA_PUBKEY(DSA **a,const unsigned char **pp,
758
 
                        long length);
759
 
#endif
760
 
OPENSSL_EXPORT int              i2d_EC_PUBKEY(const EC_KEY *a, unsigned char **pp);
761
 
OPENSSL_EXPORT EC_KEY           *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp,
762
 
                        long length);
763
 
 
764
 
DECLARE_ASN1_FUNCTIONS(X509_SIG)
765
 
DECLARE_ASN1_FUNCTIONS(X509_REQ_INFO)
766
 
DECLARE_ASN1_FUNCTIONS(X509_REQ)
767
 
 
768
 
DECLARE_ASN1_FUNCTIONS(X509_ATTRIBUTE)
769
 
OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, void *value);
770
 
 
771
 
DECLARE_ASN1_FUNCTIONS(X509_EXTENSION)
772
 
DECLARE_ASN1_ENCODE_FUNCTIONS(X509_EXTENSIONS, X509_EXTENSIONS, X509_EXTENSIONS)
773
 
 
774
 
DECLARE_ASN1_FUNCTIONS(X509_NAME_ENTRY)
775
 
 
776
 
DECLARE_ASN1_FUNCTIONS(X509_NAME)
777
 
 
778
 
OPENSSL_EXPORT int              X509_NAME_set(X509_NAME **xn, X509_NAME *name);
779
 
 
780
 
DECLARE_ASN1_FUNCTIONS(X509_CINF)
781
 
 
782
 
DECLARE_ASN1_FUNCTIONS(X509)
783
 
DECLARE_ASN1_FUNCTIONS(X509_CERT_AUX)
784
 
 
785
 
DECLARE_ASN1_FUNCTIONS(X509_CERT_PAIR)
786
 
 
787
 
/* X509_up_ref adds one to the reference count of |x| and returns
788
 
 * |x|. */
789
 
OPENSSL_EXPORT X509 *X509_up_ref(X509 *x);
790
 
 
791
 
OPENSSL_EXPORT int X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
792
 
             CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
793
 
OPENSSL_EXPORT int X509_set_ex_data(X509 *r, int idx, void *arg);
794
 
OPENSSL_EXPORT void *X509_get_ex_data(X509 *r, int idx);
795
 
OPENSSL_EXPORT int              i2d_X509_AUX(X509 *a,unsigned char **pp);
796
 
OPENSSL_EXPORT X509 *           d2i_X509_AUX(X509 **a,const unsigned char **pp,long length);
797
 
 
798
 
OPENSSL_EXPORT void X509_get0_signature(ASN1_BIT_STRING **psig, X509_ALGOR **palg,
799
 
                                                                const X509 *x);
800
 
OPENSSL_EXPORT int X509_get_signature_nid(const X509 *x);
801
 
 
802
 
OPENSSL_EXPORT int X509_alias_set1(X509 *x, unsigned char *name, int len);
803
 
OPENSSL_EXPORT int X509_keyid_set1(X509 *x, unsigned char *id, int len);
804
 
OPENSSL_EXPORT unsigned char * X509_alias_get0(X509 *x, int *len);
805
 
OPENSSL_EXPORT unsigned char * X509_keyid_get0(X509 *x, int *len);
806
 
OPENSSL_EXPORT int (*X509_TRUST_set_default(int (*trust)(int , X509 *, int)))(int, X509 *, int);
807
 
OPENSSL_EXPORT int X509_TRUST_set(int *t, int trust);
808
 
OPENSSL_EXPORT int X509_add1_trust_object(X509 *x, ASN1_OBJECT *obj);
809
 
OPENSSL_EXPORT int X509_add1_reject_object(X509 *x, ASN1_OBJECT *obj);
810
 
OPENSSL_EXPORT void X509_trust_clear(X509 *x);
811
 
OPENSSL_EXPORT void X509_reject_clear(X509 *x);
812
 
 
813
 
DECLARE_ASN1_FUNCTIONS(X509_REVOKED)
814
 
DECLARE_ASN1_FUNCTIONS(X509_CRL_INFO)
815
 
DECLARE_ASN1_FUNCTIONS(X509_CRL)
816
 
 
817
 
OPENSSL_EXPORT int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev);
818
 
OPENSSL_EXPORT int X509_CRL_get0_by_serial(X509_CRL *crl,
819
 
                X509_REVOKED **ret, ASN1_INTEGER *serial);
820
 
OPENSSL_EXPORT int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x);
821
 
 
822
 
OPENSSL_EXPORT X509_PKEY *      X509_PKEY_new(void );
823
 
OPENSSL_EXPORT void             X509_PKEY_free(X509_PKEY *a);
824
 
 
825
 
DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKI)
826
 
DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKAC)
827
 
DECLARE_ASN1_FUNCTIONS(NETSCAPE_CERT_SEQUENCE)
828
 
 
829
 
#ifndef OPENSSL_NO_EVP
830
 
OPENSSL_EXPORT X509_INFO *      X509_INFO_new(void);
831
 
OPENSSL_EXPORT void             X509_INFO_free(X509_INFO *a);
832
 
OPENSSL_EXPORT char *           X509_NAME_oneline(X509_NAME *a,char *buf,int size);
833
 
 
834
 
OPENSSL_EXPORT int ASN1_digest(i2d_of_void *i2d,const EVP_MD *type,char *data,
835
 
                unsigned char *md,unsigned int *len);
836
 
 
837
 
OPENSSL_EXPORT int ASN1_item_digest(const ASN1_ITEM *it,const EVP_MD *type,void *data,
838
 
        unsigned char *md,unsigned int *len);
839
 
 
840
 
OPENSSL_EXPORT int ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *algor1,
841
 
        ASN1_BIT_STRING *signature,void *data,EVP_PKEY *pkey);
842
 
 
843
 
OPENSSL_EXPORT int ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2,
844
 
        ASN1_BIT_STRING *signature,
845
 
        void *data, EVP_PKEY *pkey, const EVP_MD *type);
846
 
OPENSSL_EXPORT int ASN1_item_sign_ctx(const ASN1_ITEM *it,
847
 
                X509_ALGOR *algor1, X509_ALGOR *algor2,
848
 
                ASN1_BIT_STRING *signature, void *asn, EVP_MD_CTX *ctx);
849
 
#endif
850
 
 
851
 
OPENSSL_EXPORT int              X509_set_version(X509 *x,long version);
852
 
OPENSSL_EXPORT int              X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial);
853
 
OPENSSL_EXPORT ASN1_INTEGER *   X509_get_serialNumber(X509 *x);
854
 
OPENSSL_EXPORT int              X509_set_issuer_name(X509 *x, X509_NAME *name);
855
 
OPENSSL_EXPORT X509_NAME *      X509_get_issuer_name(X509 *a);
856
 
OPENSSL_EXPORT int              X509_set_subject_name(X509 *x, X509_NAME *name);
857
 
OPENSSL_EXPORT X509_NAME *      X509_get_subject_name(X509 *a);
858
 
OPENSSL_EXPORT int              X509_set_notBefore(X509 *x, const ASN1_TIME *tm);
859
 
OPENSSL_EXPORT int              X509_set_notAfter(X509 *x, const ASN1_TIME *tm);
860
 
OPENSSL_EXPORT int              X509_set_pubkey(X509 *x, EVP_PKEY *pkey);
861
 
OPENSSL_EXPORT EVP_PKEY *       X509_get_pubkey(X509 *x);
862
 
OPENSSL_EXPORT ASN1_BIT_STRING * X509_get0_pubkey_bitstr(const X509 *x);
863
 
OPENSSL_EXPORT int              X509_certificate_type(X509 *x,EVP_PKEY *pubkey /* optional */);
864
 
 
865
 
OPENSSL_EXPORT int              X509_REQ_set_version(X509_REQ *x,long version);
866
 
OPENSSL_EXPORT int              X509_REQ_set_subject_name(X509_REQ *req,X509_NAME *name);
867
 
OPENSSL_EXPORT int              X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey);
868
 
OPENSSL_EXPORT EVP_PKEY *       X509_REQ_get_pubkey(X509_REQ *req);
869
 
OPENSSL_EXPORT int              X509_REQ_extension_nid(int nid);
870
 
OPENSSL_EXPORT const int *      X509_REQ_get_extension_nids(void);
871
 
OPENSSL_EXPORT void             X509_REQ_set_extension_nids(const int *nids);
872
 
OPENSSL_EXPORT STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req);
873
 
OPENSSL_EXPORT int X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts,
874
 
                                int nid);
875
 
OPENSSL_EXPORT int X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts);
876
 
OPENSSL_EXPORT int X509_REQ_get_attr_count(const X509_REQ *req);
877
 
OPENSSL_EXPORT int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid,
878
 
                          int lastpos);
879
 
OPENSSL_EXPORT int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, ASN1_OBJECT *obj,
880
 
                          int lastpos);
881
 
OPENSSL_EXPORT X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc);
882
 
OPENSSL_EXPORT X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc);
883
 
OPENSSL_EXPORT int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr);
884
 
OPENSSL_EXPORT int X509_REQ_add1_attr_by_OBJ(X509_REQ *req,
885
 
                        const ASN1_OBJECT *obj, int type,
886
 
                        const unsigned char *bytes, int len);
887
 
OPENSSL_EXPORT int X509_REQ_add1_attr_by_NID(X509_REQ *req,
888
 
                        int nid, int type,
889
 
                        const unsigned char *bytes, int len);
890
 
OPENSSL_EXPORT int X509_REQ_add1_attr_by_txt(X509_REQ *req,
891
 
                        const char *attrname, int type,
892
 
                        const unsigned char *bytes, int len);
893
 
 
894
 
OPENSSL_EXPORT int X509_CRL_set_version(X509_CRL *x, long version);
895
 
OPENSSL_EXPORT int X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name);
896
 
OPENSSL_EXPORT int X509_CRL_set_lastUpdate(X509_CRL *x, const ASN1_TIME *tm);
897
 
OPENSSL_EXPORT int X509_CRL_set_nextUpdate(X509_CRL *x, const ASN1_TIME *tm);
898
 
OPENSSL_EXPORT int X509_CRL_sort(X509_CRL *crl);
899
 
 
900
 
OPENSSL_EXPORT int X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial);
901
 
OPENSSL_EXPORT int X509_REVOKED_set_revocationDate(X509_REVOKED *r, ASN1_TIME *tm);
902
 
 
903
 
OPENSSL_EXPORT X509_CRL *X509_CRL_diff(X509_CRL *base, X509_CRL *newer,
904
 
                        EVP_PKEY *skey, const EVP_MD *md, unsigned int flags);
905
 
 
906
 
OPENSSL_EXPORT int              X509_REQ_check_private_key(X509_REQ *x509,EVP_PKEY *pkey);
907
 
 
908
 
OPENSSL_EXPORT int              X509_check_private_key(X509 *x509,EVP_PKEY *pkey);
909
 
OPENSSL_EXPORT int              X509_chain_check_suiteb(int *perror_depth,
910
 
                                                X509 *x, STACK_OF(X509) *chain,
911
 
                                                unsigned long flags);
912
 
OPENSSL_EXPORT int              X509_CRL_check_suiteb(X509_CRL *crl, EVP_PKEY *pk,
913
 
                                                unsigned long flags);
914
 
OPENSSL_EXPORT STACK_OF(X509) *X509_chain_up_ref(STACK_OF(X509) *chain);
915
 
 
916
 
OPENSSL_EXPORT int              X509_issuer_and_serial_cmp(const X509 *a, const X509 *b);
917
 
OPENSSL_EXPORT unsigned long    X509_issuer_and_serial_hash(X509 *a);
918
 
 
919
 
OPENSSL_EXPORT int              X509_issuer_name_cmp(const X509 *a, const X509 *b);
920
 
OPENSSL_EXPORT unsigned long    X509_issuer_name_hash(X509 *a);
921
 
 
922
 
OPENSSL_EXPORT int              X509_subject_name_cmp(const X509 *a, const X509 *b);
923
 
OPENSSL_EXPORT unsigned long    X509_subject_name_hash(X509 *x);
924
 
 
925
 
OPENSSL_EXPORT unsigned long    X509_issuer_name_hash_old(X509 *a);
926
 
OPENSSL_EXPORT unsigned long    X509_subject_name_hash_old(X509 *x);
927
 
 
928
 
OPENSSL_EXPORT int              X509_cmp(const X509 *a, const X509 *b);
929
 
OPENSSL_EXPORT int              X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b);
930
 
OPENSSL_EXPORT unsigned long    X509_NAME_hash(X509_NAME *x);
931
 
OPENSSL_EXPORT unsigned long    X509_NAME_hash_old(X509_NAME *x);
932
 
 
933
 
OPENSSL_EXPORT int              X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b);
934
 
OPENSSL_EXPORT int              X509_CRL_match(const X509_CRL *a, const X509_CRL *b);
935
 
#ifndef OPENSSL_NO_FP_API
936
 
OPENSSL_EXPORT int              X509_print_ex_fp(FILE *bp,X509 *x, unsigned long nmflag, unsigned long cflag);
937
 
OPENSSL_EXPORT int              X509_print_fp(FILE *bp,X509 *x);
938
 
OPENSSL_EXPORT int              X509_CRL_print_fp(FILE *bp,X509_CRL *x);
939
 
OPENSSL_EXPORT int              X509_REQ_print_fp(FILE *bp,X509_REQ *req);
940
 
OPENSSL_EXPORT int X509_NAME_print_ex_fp(FILE *fp, X509_NAME *nm, int indent, unsigned long flags);
941
 
#endif
942
 
 
943
 
OPENSSL_EXPORT int              X509_NAME_print(BIO *bp, X509_NAME *name, int obase);
944
 
OPENSSL_EXPORT int X509_NAME_print_ex(BIO *out, X509_NAME *nm, int indent, unsigned long flags);
945
 
OPENSSL_EXPORT int              X509_print_ex(BIO *bp,X509 *x, unsigned long nmflag, unsigned long cflag);
946
 
OPENSSL_EXPORT int              X509_print(BIO *bp,X509 *x);
947
 
OPENSSL_EXPORT int              X509_ocspid_print(BIO *bp,X509 *x);
948
 
OPENSSL_EXPORT int              X509_CERT_AUX_print(BIO *bp,X509_CERT_AUX *x, int indent);
949
 
OPENSSL_EXPORT int              X509_CRL_print(BIO *bp,X509_CRL *x);
950
 
OPENSSL_EXPORT int              X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag, unsigned long cflag);
951
 
OPENSSL_EXPORT int              X509_REQ_print(BIO *bp,X509_REQ *req);
952
 
 
953
 
OPENSSL_EXPORT int              X509_NAME_entry_count(X509_NAME *name);
954
 
OPENSSL_EXPORT int              X509_NAME_get_text_by_NID(X509_NAME *name, int nid,
955
 
                        char *buf,int len);
956
 
OPENSSL_EXPORT int              X509_NAME_get_text_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj,
957
 
                        char *buf,int len);
958
 
 
959
 
/* NOTE: you should be passsing -1, not 0 as lastpos.  The functions that use
960
 
 * lastpos, search after that position on. */
961
 
OPENSSL_EXPORT int              X509_NAME_get_index_by_NID(X509_NAME *name,int nid,int lastpos);
962
 
OPENSSL_EXPORT int              X509_NAME_get_index_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj,
963
 
                        int lastpos);
964
 
OPENSSL_EXPORT X509_NAME_ENTRY *X509_NAME_get_entry(X509_NAME *name, int loc);
965
 
OPENSSL_EXPORT X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc);
966
 
OPENSSL_EXPORT int              X509_NAME_add_entry(X509_NAME *name,X509_NAME_ENTRY *ne,
967
 
                        int loc, int set);
968
 
OPENSSL_EXPORT int X509_NAME_add_entry_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj, int type,
969
 
                        unsigned char *bytes, int len, int loc, int set);
970
 
OPENSSL_EXPORT int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
971
 
                        unsigned char *bytes, int len, int loc, int set);
972
 
OPENSSL_EXPORT X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
973
 
                const char *field, int type, const unsigned char *bytes, int len);
974
 
OPENSSL_EXPORT X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid,
975
 
                        int type,unsigned char *bytes, int len);
976
 
OPENSSL_EXPORT int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
977
 
                        const unsigned char *bytes, int len, int loc, int set);
978
 
OPENSSL_EXPORT X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne,
979
 
                        const ASN1_OBJECT *obj, int type,const unsigned char *bytes,
980
 
                        int len);
981
 
OPENSSL_EXPORT int              X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne,
982
 
                        const ASN1_OBJECT *obj);
983
 
OPENSSL_EXPORT int              X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
984
 
                        const unsigned char *bytes, int len);
985
 
OPENSSL_EXPORT ASN1_OBJECT *    X509_NAME_ENTRY_get_object(X509_NAME_ENTRY *ne);
986
 
OPENSSL_EXPORT ASN1_STRING *    X509_NAME_ENTRY_get_data(X509_NAME_ENTRY *ne);
987
 
 
988
 
OPENSSL_EXPORT int              X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x);
989
 
OPENSSL_EXPORT int              X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x,
990
 
                                      int nid, int lastpos);
991
 
OPENSSL_EXPORT int              X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *x,
992
 
                                      const ASN1_OBJECT *obj,int lastpos);
993
 
OPENSSL_EXPORT int              X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *x,
994
 
                                           int crit, int lastpos);
995
 
OPENSSL_EXPORT X509_EXTENSION *X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc);
996
 
OPENSSL_EXPORT X509_EXTENSION *X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc);
997
 
OPENSSL_EXPORT STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x,
998
 
                                         X509_EXTENSION *ex, int loc);
999
 
 
1000
 
OPENSSL_EXPORT int              X509_get_ext_count(X509 *x);
1001
 
OPENSSL_EXPORT int              X509_get_ext_by_NID(X509 *x, int nid, int lastpos);
1002
 
OPENSSL_EXPORT int              X509_get_ext_by_OBJ(X509 *x,ASN1_OBJECT *obj,int lastpos);
1003
 
OPENSSL_EXPORT int              X509_get_ext_by_critical(X509 *x, int crit, int lastpos);
1004
 
OPENSSL_EXPORT X509_EXTENSION *X509_get_ext(X509 *x, int loc);
1005
 
OPENSSL_EXPORT X509_EXTENSION *X509_delete_ext(X509 *x, int loc);
1006
 
OPENSSL_EXPORT int              X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc);
1007
 
OPENSSL_EXPORT void     *       X509_get_ext_d2i(X509 *x, int nid, int *crit, int *idx);
1008
 
OPENSSL_EXPORT int              X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit,
1009
 
                                                        unsigned long flags);
1010
 
 
1011
 
OPENSSL_EXPORT int              X509_CRL_get_ext_count(X509_CRL *x);
1012
 
OPENSSL_EXPORT int              X509_CRL_get_ext_by_NID(X509_CRL *x, int nid, int lastpos);
1013
 
OPENSSL_EXPORT int              X509_CRL_get_ext_by_OBJ(X509_CRL *x,ASN1_OBJECT *obj,int lastpos);
1014
 
OPENSSL_EXPORT int              X509_CRL_get_ext_by_critical(X509_CRL *x, int crit, int lastpos);
1015
 
OPENSSL_EXPORT X509_EXTENSION *X509_CRL_get_ext(X509_CRL *x, int loc);
1016
 
OPENSSL_EXPORT X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc);
1017
 
OPENSSL_EXPORT int              X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc);
1018
 
OPENSSL_EXPORT void     *       X509_CRL_get_ext_d2i(X509_CRL *x, int nid, int *crit, int *idx);
1019
 
OPENSSL_EXPORT int              X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit,
1020
 
                                                        unsigned long flags);
1021
 
 
1022
 
OPENSSL_EXPORT int              X509_REVOKED_get_ext_count(X509_REVOKED *x);
1023
 
OPENSSL_EXPORT int              X509_REVOKED_get_ext_by_NID(X509_REVOKED *x, int nid, int lastpos);
1024
 
OPENSSL_EXPORT int              X509_REVOKED_get_ext_by_OBJ(X509_REVOKED *x,ASN1_OBJECT *obj,int lastpos);
1025
 
OPENSSL_EXPORT int              X509_REVOKED_get_ext_by_critical(X509_REVOKED *x, int crit, int lastpos);
1026
 
OPENSSL_EXPORT X509_EXTENSION *X509_REVOKED_get_ext(X509_REVOKED *x, int loc);
1027
 
OPENSSL_EXPORT X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc);
1028
 
OPENSSL_EXPORT int              X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc);
1029
 
OPENSSL_EXPORT void     *       X509_REVOKED_get_ext_d2i(X509_REVOKED *x, int nid, int *crit, int *idx);
1030
 
OPENSSL_EXPORT int              X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,
1031
 
                                                        unsigned long flags);
1032
 
 
1033
 
OPENSSL_EXPORT X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex,
1034
 
                        int nid, int crit, ASN1_OCTET_STRING *data);
1035
 
OPENSSL_EXPORT X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex,
1036
 
                        const ASN1_OBJECT *obj,int crit,ASN1_OCTET_STRING *data);
1037
 
OPENSSL_EXPORT int              X509_EXTENSION_set_object(X509_EXTENSION *ex,const ASN1_OBJECT *obj);
1038
 
OPENSSL_EXPORT int              X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit);
1039
 
OPENSSL_EXPORT int              X509_EXTENSION_set_data(X509_EXTENSION *ex,
1040
 
                        ASN1_OCTET_STRING *data);
1041
 
OPENSSL_EXPORT ASN1_OBJECT *    X509_EXTENSION_get_object(X509_EXTENSION *ex);
1042
 
OPENSSL_EXPORT ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne);
1043
 
OPENSSL_EXPORT int              X509_EXTENSION_get_critical(X509_EXTENSION *ex);
1044
 
 
1045
 
OPENSSL_EXPORT int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x);
1046
 
OPENSSL_EXPORT int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
1047
 
                          int lastpos);
1048
 
OPENSSL_EXPORT int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, const ASN1_OBJECT *obj,
1049
 
                          int lastpos);
1050
 
OPENSSL_EXPORT X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc);
1051
 
OPENSSL_EXPORT X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc);
1052
 
OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x,
1053
 
                                         X509_ATTRIBUTE *attr);
1054
 
OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x,
1055
 
                        const ASN1_OBJECT *obj, int type,
1056
 
                        const unsigned char *bytes, int len);
1057
 
OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x,
1058
 
                        int nid, int type,
1059
 
                        const unsigned char *bytes, int len);
1060
 
OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x,
1061
 
                        const char *attrname, int type,
1062
 
                        const unsigned char *bytes, int len);
1063
 
OPENSSL_EXPORT void *X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x,
1064
 
                                ASN1_OBJECT *obj, int lastpos, int type);
1065
 
OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
1066
 
             int atrtype, const void *data, int len);
1067
 
OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
1068
 
             const ASN1_OBJECT *obj, int atrtype, const void *data, int len);
1069
 
OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
1070
 
                const char *atrname, int type, const unsigned char *bytes, int len);
1071
 
OPENSSL_EXPORT int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj);
1072
 
OPENSSL_EXPORT int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *data, int len);
1073
 
OPENSSL_EXPORT void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx,
1074
 
                                        int atrtype, void *data);
1075
 
OPENSSL_EXPORT int X509_ATTRIBUTE_count(X509_ATTRIBUTE *attr);
1076
 
OPENSSL_EXPORT ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr);
1077
 
OPENSSL_EXPORT ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx);
1078
 
 
1079
 
OPENSSL_EXPORT int EVP_PKEY_get_attr_count(const EVP_PKEY *key);
1080
 
OPENSSL_EXPORT int EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid,
1081
 
                          int lastpos);
1082
 
OPENSSL_EXPORT int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, ASN1_OBJECT *obj,
1083
 
                          int lastpos);
1084
 
OPENSSL_EXPORT X509_ATTRIBUTE *EVP_PKEY_get_attr(const EVP_PKEY *key, int loc);
1085
 
OPENSSL_EXPORT X509_ATTRIBUTE *EVP_PKEY_delete_attr(EVP_PKEY *key, int loc);
1086
 
OPENSSL_EXPORT int EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr);
1087
 
OPENSSL_EXPORT int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key,
1088
 
                        const ASN1_OBJECT *obj, int type,
1089
 
                        const unsigned char *bytes, int len);
1090
 
OPENSSL_EXPORT int EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key,
1091
 
                        int nid, int type,
1092
 
                        const unsigned char *bytes, int len);
1093
 
OPENSSL_EXPORT int EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key,
1094
 
                        const char *attrname, int type,
1095
 
                        const unsigned char *bytes, int len);
1096
 
 
1097
 
OPENSSL_EXPORT int              X509_verify_cert(X509_STORE_CTX *ctx);
1098
 
 
1099
 
/* lookup a cert from a X509 STACK */
1100
 
OPENSSL_EXPORT X509 *X509_find_by_issuer_and_serial(STACK_OF(X509) *sk,X509_NAME *name,
1101
 
                                     ASN1_INTEGER *serial);
1102
 
OPENSSL_EXPORT X509 *X509_find_by_subject(STACK_OF(X509) *sk,X509_NAME *name);
1103
 
 
1104
 
DECLARE_ASN1_FUNCTIONS(PBEPARAM)
1105
 
DECLARE_ASN1_FUNCTIONS(PBE2PARAM)
1106
 
DECLARE_ASN1_FUNCTIONS(PBKDF2PARAM)
1107
 
 
1108
 
OPENSSL_EXPORT int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,
1109
 
                                const unsigned char *salt, int saltlen);
1110
 
 
1111
 
OPENSSL_EXPORT X509_ALGOR *PKCS5_pbe_set(int alg, int iter,
1112
 
                                const unsigned char *salt, int saltlen);
1113
 
OPENSSL_EXPORT X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter,
1114
 
                                         unsigned char *salt, int saltlen);
1115
 
OPENSSL_EXPORT X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter,
1116
 
                                 unsigned char *salt, int saltlen,
1117
 
                                 unsigned char *aiv, int prf_nid);
1118
 
 
1119
 
OPENSSL_EXPORT X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen,
1120
 
                                int prf_nid, int keylen);
1121
 
 
1122
 
/* PKCS#8 utilities */
1123
 
 
1124
 
DECLARE_ASN1_FUNCTIONS(PKCS8_PRIV_KEY_INFO)
1125
 
 
1126
 
OPENSSL_EXPORT EVP_PKEY *EVP_PKCS82PKEY(PKCS8_PRIV_KEY_INFO *p8);
1127
 
OPENSSL_EXPORT PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(EVP_PKEY *pkey);
1128
 
OPENSSL_EXPORT PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8_broken(EVP_PKEY *pkey, int broken);
1129
 
OPENSSL_EXPORT PKCS8_PRIV_KEY_INFO *PKCS8_set_broken(PKCS8_PRIV_KEY_INFO *p8, int broken);
1130
 
 
1131
 
OPENSSL_EXPORT int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj,
1132
 
                        int version, int ptype, void *pval,
1133
 
                                unsigned char *penc, int penclen);
1134
 
OPENSSL_EXPORT int PKCS8_pkey_get0(ASN1_OBJECT **ppkalg,
1135
 
                const unsigned char **pk, int *ppklen,
1136
 
                X509_ALGOR **pa,
1137
 
                PKCS8_PRIV_KEY_INFO *p8);
1138
 
 
1139
 
OPENSSL_EXPORT int X509_PUBKEY_set0_param(X509_PUBKEY *pub, const ASN1_OBJECT *aobj,
1140
 
                                        int ptype, void *pval,
1141
 
                                        unsigned char *penc, int penclen);
1142
 
OPENSSL_EXPORT int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg,
1143
 
                const unsigned char **pk, int *ppklen,
1144
 
                X509_ALGOR **pa,
1145
 
                X509_PUBKEY *pub);
1146
 
 
1147
 
OPENSSL_EXPORT int X509_check_trust(X509 *x, int id, int flags);
1148
 
OPENSSL_EXPORT int X509_TRUST_get_count(void);
1149
 
OPENSSL_EXPORT X509_TRUST * X509_TRUST_get0(int idx);
1150
 
OPENSSL_EXPORT int X509_TRUST_get_by_id(int id);
1151
 
OPENSSL_EXPORT int X509_TRUST_add(int id, int flags, int (*ck)(X509_TRUST *, X509 *, int),
1152
 
                                        char *name, int arg1, void *arg2);
1153
 
OPENSSL_EXPORT void X509_TRUST_cleanup(void);
1154
 
OPENSSL_EXPORT int X509_TRUST_get_flags(X509_TRUST *xp);
1155
 
OPENSSL_EXPORT char *X509_TRUST_get0_name(X509_TRUST *xp);
1156
 
OPENSSL_EXPORT int X509_TRUST_get_trust(X509_TRUST *xp);
1157
 
 
1158
 
/* PKCS7_get_certificates parses a PKCS#7, SignedData structure from |cbs| and
1159
 
 * appends the included certificates to |out_certs|. It returns one on success
1160
 
 * and zero on error. */
1161
 
OPENSSL_EXPORT int PKCS7_get_certificates(STACK_OF(X509) *out_certs, CBS *cbs);
1162
 
 
1163
 
/* PKCS7_bundle_certificates appends a PKCS#7, SignedData structure containing
1164
 
 * |certs| to |out|. It returns one on success and zero on error. */
1165
 
OPENSSL_EXPORT int PKCS7_bundle_certificates(
1166
 
    CBB *out, const STACK_OF(X509) *certs);
1167
 
 
1168
 
/* PKCS7_get_CRLs parses a PKCS#7, SignedData structure from |cbs| and appends
1169
 
 * the included CRLs to |out_crls|. It returns one on success and zero on
1170
 
 * error. */
1171
 
OPENSSL_EXPORT int PKCS7_get_CRLs(STACK_OF(X509_CRL) *out_crls, CBS *cbs);
1172
 
 
1173
 
/* PKCS7_bundle_CRLs appends a PKCS#7, SignedData structure containing
1174
 
 * |crls| to |out|. It returns one on success and zero on error. */
1175
 
OPENSSL_EXPORT int PKCS7_bundle_CRLs(CBB *out, const STACK_OF(X509_CRL) *crls);
1176
 
 
1177
 
/* PKCS7_get_PEM_certificates reads a PEM-encoded, PKCS#7, SignedData structure
1178
 
 * from |pem_bio| and appends the included certificates to |out_certs|. It
1179
 
 * returns one on success and zero on error. */
1180
 
OPENSSL_EXPORT int PKCS7_get_PEM_certificates(STACK_OF(X509) *out_certs,
1181
 
                                              BIO *pem_bio);
1182
 
 
1183
 
/* PKCS7_get_PEM_CRLs reads a PEM-encoded, PKCS#7, SignedData structure from
1184
 
 * |pem_bio| and appends the included CRLs to |out_crls|. It returns one on
1185
 
 * success and zero on error. */
1186
 
OPENSSL_EXPORT int PKCS7_get_PEM_CRLs(STACK_OF(X509_CRL) *out_crls,
1187
 
                                      BIO *pem_bio);
1188
 
 
1189
 
/* EVP_PK values indicate the algorithm of the public key in a certificate. */
1190
 
 
1191
 
#define EVP_PK_RSA      0x0001
1192
 
#define EVP_PK_DSA      0x0002
1193
 
#define EVP_PK_DH       0x0004
1194
 
#define EVP_PK_EC       0x0008
1195
 
 
1196
 
/* EVP_PKS values indicate the algorithm used to sign a certificate. */
1197
 
 
1198
 
#define EVP_PKS_RSA 0x0100
1199
 
#define EVP_PKS_DSA 0x0200
1200
 
#define EVP_PKS_EC 0x0400
1201
 
 
1202
 
/* EVP_PKT values are flags that define what public-key operations can be
1203
 
 * performed with the public key from a certificate. */
1204
 
 
1205
 
/* EVP_PKT_SIGN indicates that the public key can be used for signing. */
1206
 
#define EVP_PKT_SIGN 0x0010
1207
 
/* EVP_PKT_ENC indicates that a session key can be encrypted to the public
1208
 
 * key. */
1209
 
#define EVP_PKT_ENC 0x0020
1210
 
/* EVP_PKT_EXCH indicates that key-agreement can be performed. */
1211
 
#define EVP_PKT_EXCH 0x0040
1212
 
/* EVP_PKT_EXP indicates that key is weak (i.e. "export"). */
1213
 
#define EVP_PKT_EXP 0x1000
1214
 
 
1215
 
 
1216
 
#ifdef  __cplusplus
1217
 
}
1218
 
#endif
1219
 
 
1220
 
#define X509_F_ASN1_digest 100
1221
 
#define X509_F_ASN1_item_sign_ctx 101
1222
 
#define X509_F_ASN1_item_verify 102
1223
 
#define X509_F_NETSCAPE_SPKI_b64_decode 103
1224
 
#define X509_F_NETSCAPE_SPKI_b64_encode 104
1225
 
#define X509_F_PKCS7_get_certificates 105
1226
 
#define X509_F_X509_ATTRIBUTE_create_by_NID 106
1227
 
#define X509_F_X509_ATTRIBUTE_create_by_OBJ 107
1228
 
#define X509_F_X509_ATTRIBUTE_create_by_txt 108
1229
 
#define X509_F_X509_ATTRIBUTE_get0_data 109
1230
 
#define X509_F_X509_ATTRIBUTE_set1_data 110
1231
 
#define X509_F_X509_CRL_add0_revoked 111
1232
 
#define X509_F_X509_CRL_diff 112
1233
 
#define X509_F_X509_CRL_print_fp 113
1234
 
#define X509_F_X509_EXTENSION_create_by_NID 114
1235
 
#define X509_F_X509_EXTENSION_create_by_OBJ 115
1236
 
#define X509_F_X509_INFO_new 116
1237
 
#define X509_F_X509_NAME_ENTRY_create_by_NID 117
1238
 
#define X509_F_X509_NAME_ENTRY_create_by_txt 118
1239
 
#define X509_F_X509_NAME_ENTRY_set_object 119
1240
 
#define X509_F_X509_NAME_add_entry 120
1241
 
#define X509_F_X509_NAME_oneline 121
1242
 
#define X509_F_X509_NAME_print 122
1243
 
#define X509_F_X509_PKEY_new 123
1244
 
#define X509_F_X509_PUBKEY_get 124
1245
 
#define X509_F_X509_PUBKEY_set 125
1246
 
#define X509_F_X509_REQ_check_private_key 126
1247
 
#define X509_F_X509_REQ_to_X509 127
1248
 
#define X509_F_X509_STORE_CTX_get1_issuer 128
1249
 
#define X509_F_X509_STORE_CTX_init 129
1250
 
#define X509_F_X509_STORE_CTX_new 130
1251
 
#define X509_F_X509_STORE_CTX_purpose_inherit 131
1252
 
#define X509_F_X509_STORE_add_cert 132
1253
 
#define X509_F_X509_STORE_add_crl 133
1254
 
#define X509_F_X509_TRUST_add 134
1255
 
#define X509_F_X509_TRUST_set 135
1256
 
#define X509_F_X509_check_private_key 136
1257
 
#define X509_F_X509_get_pubkey_parameters 137
1258
 
#define X509_F_X509_load_cert_crl_file 138
1259
 
#define X509_F_X509_load_cert_file 139
1260
 
#define X509_F_X509_load_crl_file 140
1261
 
#define X509_F_X509_print_ex_fp 141
1262
 
#define X509_F_X509_to_X509_REQ 142
1263
 
#define X509_F_X509_verify_cert 143
1264
 
#define X509_F_X509at_add1_attr 144
1265
 
#define X509_F_X509v3_add_ext 145
1266
 
#define X509_F_add_cert_dir 146
1267
 
#define X509_F_by_file_ctrl 147
1268
 
#define X509_F_check_policy 148
1269
 
#define X509_F_dir_ctrl 149
1270
 
#define X509_F_get_cert_by_subject 150
1271
 
#define X509_F_i2d_DSA_PUBKEY 151
1272
 
#define X509_F_i2d_EC_PUBKEY 152
1273
 
#define X509_F_i2d_RSA_PUBKEY 153
1274
 
#define X509_F_x509_name_encode 154
1275
 
#define X509_F_x509_name_ex_d2i 155
1276
 
#define X509_F_x509_name_ex_new 156
1277
 
#define X509_F_pkcs7_parse_header 157
1278
 
#define X509_F_PKCS7_get_CRLs 158
1279
 
#define X509_R_AKID_MISMATCH 100
1280
 
#define X509_R_BAD_PKCS7_VERSION 101
1281
 
#define X509_R_BAD_X509_FILETYPE 102
1282
 
#define X509_R_BASE64_DECODE_ERROR 103
1283
 
#define X509_R_CANT_CHECK_DH_KEY 104
1284
 
#define X509_R_CERT_ALREADY_IN_HASH_TABLE 105
1285
 
#define X509_R_CRL_ALREADY_DELTA 106
1286
 
#define X509_R_CRL_VERIFY_FAILURE 107
1287
 
#define X509_R_IDP_MISMATCH 108
1288
 
#define X509_R_INVALID_BIT_STRING_BITS_LEFT 109
1289
 
#define X509_R_INVALID_DIRECTORY 110
1290
 
#define X509_R_INVALID_FIELD_NAME 111
1291
 
#define X509_R_INVALID_TRUST 112
1292
 
#define X509_R_ISSUER_MISMATCH 113
1293
 
#define X509_R_KEY_TYPE_MISMATCH 114
1294
 
#define X509_R_KEY_VALUES_MISMATCH 115
1295
 
#define X509_R_LOADING_CERT_DIR 116
1296
 
#define X509_R_LOADING_DEFAULTS 117
1297
 
#define X509_R_METHOD_NOT_SUPPORTED 118
1298
 
#define X509_R_NEWER_CRL_NOT_NEWER 119
1299
 
#define X509_R_NOT_PKCS7_SIGNED_DATA 120
1300
 
#define X509_R_NO_CERTIFICATES_INCLUDED 121
1301
 
#define X509_R_NO_CERT_SET_FOR_US_TO_VERIFY 122
1302
 
#define X509_R_NO_CRL_NUMBER 123
1303
 
#define X509_R_PUBLIC_KEY_DECODE_ERROR 124
1304
 
#define X509_R_PUBLIC_KEY_ENCODE_ERROR 125
1305
 
#define X509_R_SHOULD_RETRY 126
1306
 
#define X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN 127
1307
 
#define X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY 128
1308
 
#define X509_R_UNKNOWN_KEY_TYPE 129
1309
 
#define X509_R_UNKNOWN_NID 130
1310
 
#define X509_R_UNKNOWN_PURPOSE_ID 131
1311
 
#define X509_R_UNKNOWN_TRUST_ID 132
1312
 
#define X509_R_UNSUPPORTED_ALGORITHM 133
1313
 
#define X509_R_WRONG_LOOKUP_TYPE 134
1314
 
#define X509_R_WRONG_TYPE 135
1315
 
#define X509_R_NO_CRLS_INCLUDED 136
1316
 
 
1317
 
#endif