GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: lib/libcrypto/x509/x_all.c Lines: 35 119 29.4 %
Date: 2017-11-07 Branches: 2 8 25.0 %

Line Branch Exec Source
1
/* $OpenBSD: x_all.c,v 1.23 2016/12/30 15:24:51 jsing Exp $ */
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
#include <stdio.h>
60
61
#include <openssl/opensslconf.h>
62
63
#include <openssl/asn1.h>
64
#include <openssl/buffer.h>
65
#include <openssl/evp.h>
66
#include <openssl/stack.h>
67
#include <openssl/x509.h>
68
69
#ifndef OPENSSL_NO_DSA
70
#include <openssl/dsa.h>
71
#endif
72
#ifndef OPENSSL_NO_RSA
73
#include <openssl/rsa.h>
74
#endif
75
76
X509 *
77
d2i_X509_bio(BIO *bp, X509 **x509)
78
{
79
4
	return ASN1_item_d2i_bio(&X509_it, bp, x509);
80
}
81
82
int
83
i2d_X509_bio(BIO *bp, X509 *x509)
84
{
85
4
	return ASN1_item_i2d_bio(&X509_it, bp, x509);
86
}
87
88
X509 *
89
d2i_X509_fp(FILE *fp, X509 **x509)
90
{
91
	return ASN1_item_d2i_fp(&X509_it, fp, x509);
92
}
93
94
int
95
i2d_X509_fp(FILE *fp, X509 *x509)
96
{
97
	return ASN1_item_i2d_fp(&X509_it, fp, x509);
98
}
99
100
X509_CRL *
101
d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl)
102
{
103
	return ASN1_item_d2i_bio(&X509_CRL_it, bp, crl);
104
}
105
106
int
107
i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl)
108
{
109
	return ASN1_item_i2d_bio(&X509_CRL_it, bp, crl);
110
}
111
112
X509_CRL *
113
d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl)
114
{
115
	return ASN1_item_d2i_fp(&X509_CRL_it, fp, crl);
116
}
117
118
int
119
i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl)
120
{
121
	return ASN1_item_i2d_fp(&X509_CRL_it, fp, crl);
122
}
123
124
PKCS7 *
125
d2i_PKCS7_bio(BIO *bp, PKCS7 **p7)
126
{
127
	return ASN1_item_d2i_bio(&PKCS7_it, bp, p7);
128
}
129
130
int
131
i2d_PKCS7_bio(BIO *bp, PKCS7 *p7)
132
{
133
	return ASN1_item_i2d_bio(&PKCS7_it, bp, p7);
134
}
135
136
PKCS7 *
137
d2i_PKCS7_fp(FILE *fp, PKCS7 **p7)
138
{
139
	return ASN1_item_d2i_fp(&PKCS7_it, fp, p7);
140
}
141
142
int
143
i2d_PKCS7_fp(FILE *fp, PKCS7 *p7)
144
{
145
	return ASN1_item_i2d_fp(&PKCS7_it, fp, p7);
146
}
147
148
X509_REQ *
149
d2i_X509_REQ_bio(BIO *bp, X509_REQ **req)
150
{
151
	return ASN1_item_d2i_bio(&X509_REQ_it, bp, req);
152
}
153
154
int
155
i2d_X509_REQ_bio(BIO *bp, X509_REQ *req)
156
{
157
	return ASN1_item_i2d_bio(&X509_REQ_it, bp, req);
158
}
159
160
X509_REQ *
161
d2i_X509_REQ_fp(FILE *fp, X509_REQ **req)
162
{
163
	return ASN1_item_d2i_fp(&X509_REQ_it, fp, req);
164
}
165
166
int
167
i2d_X509_REQ_fp(FILE *fp, X509_REQ *req)
168
{
169
	return ASN1_item_i2d_fp(&X509_REQ_it, fp, req);
170
}
171
172
#ifndef OPENSSL_NO_RSA
173
RSA *
174
d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa)
175
{
176
	return ASN1_item_d2i_bio(&RSAPrivateKey_it, bp, rsa);
177
}
178
179
int
180
i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa)
181
{
182
	return ASN1_item_i2d_bio(&RSAPrivateKey_it, bp, rsa);
183
}
184
185
RSA *
186
d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa)
187
{
188
	return ASN1_item_d2i_fp(&RSAPrivateKey_it, fp, rsa);
189
}
190
191
int
192
i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa)
193
{
194
	return ASN1_item_i2d_fp(&RSAPrivateKey_it, fp, rsa);
195
}
196
197
RSA *
198
d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa)
199
{
200
	return ASN1_item_d2i_bio(&RSAPublicKey_it, bp, rsa);
201
}
202
203
int
204
i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa)
205
{
206
	return ASN1_item_i2d_bio(&RSAPublicKey_it, bp, rsa);
207
}
208
209
RSA *
210
d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa)
211
{
212
	return ASN1_item_d2i_fp(&RSAPublicKey_it, fp, rsa);
213
}
214
215
int
216
i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa)
217
{
218
	return ASN1_item_i2d_fp(&RSAPublicKey_it, fp, rsa);
219
}
220
221
RSA *
222
d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa)
223
{
224
	return ASN1_d2i_bio_of(RSA, RSA_new, d2i_RSA_PUBKEY, bp, rsa);
225
}
226
227
int
228
i2d_RSA_PUBKEY_bio(BIO *bp, RSA *rsa)
229
{
230
	return ASN1_i2d_bio_of(RSA, i2d_RSA_PUBKEY, bp, rsa);
231
}
232
233
int
234
i2d_RSA_PUBKEY_fp(FILE *fp, RSA *rsa)
235
{
236
	return ASN1_i2d_fp((I2D_OF(void))i2d_RSA_PUBKEY, fp, rsa);
237
}
238
239
RSA *
240
d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa)
241
{
242
	return ASN1_d2i_fp((void *(*)(void))RSA_new,
243
	    (D2I_OF(void))d2i_RSA_PUBKEY, fp, (void **)rsa);
244
}
245
#endif
246
247
#ifndef OPENSSL_NO_DSA
248
DSA *
249
d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa)
250
{
251
	return ASN1_item_d2i_bio(&DSAPrivateKey_it, bp, dsa);
252
}
253
254
int
255
i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa)
256
{
257
	return ASN1_item_i2d_bio(&DSAPrivateKey_it, bp, dsa);
258
}
259
260
DSA *
261
d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa)
262
{
263
	return ASN1_item_d2i_fp(&DSAPrivateKey_it, fp, dsa);
264
}
265
266
int
267
i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa)
268
{
269
	return ASN1_item_i2d_fp(&DSAPrivateKey_it, fp, dsa);
270
}
271
272
DSA *
273
d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa)
274
{
275
	return ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSA_PUBKEY, bp, dsa);
276
}
277
278
int
279
i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa)
280
{
281
	return ASN1_i2d_bio_of(DSA, i2d_DSA_PUBKEY, bp, dsa);
282
}
283
284
DSA *
285
d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa)
286
{
287
	return ASN1_d2i_fp_of(DSA, DSA_new, d2i_DSA_PUBKEY, fp, dsa);
288
}
289
290
int
291
i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa)
292
{
293
	return ASN1_i2d_fp_of(DSA, i2d_DSA_PUBKEY, fp, dsa);
294
}
295
#endif
296
297
#ifndef OPENSSL_NO_EC
298
EC_KEY *
299
d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey)
300
{
301
	return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, bp, eckey);
302
}
303
304
int
305
i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey)
306
{
307
	return ASN1_i2d_bio_of(EC_KEY, i2d_ECPrivateKey, bp, eckey);
308
}
309
310
EC_KEY *
311
d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey)
312
{
313
	return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, fp, eckey);
314
}
315
316
int
317
i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey)
318
{
319
	return ASN1_i2d_fp_of(EC_KEY, i2d_ECPrivateKey, fp, eckey);
320
}
321
322
EC_KEY *
323
d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey)
324
{
325
	return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_EC_PUBKEY, bp, eckey);
326
}
327
328
int
329
i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *ecdsa)
330
{
331
	return ASN1_i2d_bio_of(EC_KEY, i2d_EC_PUBKEY, bp, ecdsa);
332
}
333
EC_KEY *
334
d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey)
335
{
336
	return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_EC_PUBKEY, fp, eckey);
337
}
338
339
int
340
i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey)
341
{
342
	return ASN1_i2d_fp_of(EC_KEY, i2d_EC_PUBKEY, fp, eckey);
343
}
344
#endif
345
346
X509_SIG *
347
d2i_PKCS8_bio(BIO *bp, X509_SIG **p8)
348
{
349
	return ASN1_item_d2i_bio(&X509_SIG_it, bp, p8);
350
}
351
352
int
353
i2d_PKCS8_bio(BIO *bp, X509_SIG *p8)
354
{
355
	return ASN1_item_i2d_bio(&X509_SIG_it, bp, p8);
356
}
357
358
X509_SIG *
359
d2i_PKCS8_fp(FILE *fp, X509_SIG **p8)
360
{
361
	return ASN1_item_d2i_fp(&X509_SIG_it, fp, p8);
362
}
363
364
int
365
i2d_PKCS8_fp(FILE *fp, X509_SIG *p8)
366
{
367
	return ASN1_item_i2d_fp(&X509_SIG_it, fp, p8);
368
}
369
370
PKCS8_PRIV_KEY_INFO *
371
d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO **p8inf)
372
{
373
	return ASN1_item_d2i_bio(&PKCS8_PRIV_KEY_INFO_it, bp,
374
	    p8inf);
375
}
376
377
int
378
i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf)
379
{
380
	return ASN1_item_i2d_bio(&PKCS8_PRIV_KEY_INFO_it, bp,
381
	    p8inf);
382
}
383
384
PKCS8_PRIV_KEY_INFO *
385
d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO **p8inf)
386
{
387
	return ASN1_item_d2i_fp(&PKCS8_PRIV_KEY_INFO_it, fp,
388
	    p8inf);
389
}
390
391
int
392
i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf)
393
{
394
	return ASN1_item_i2d_fp(&PKCS8_PRIV_KEY_INFO_it, fp,
395
	    p8inf);
396
}
397
398
EVP_PKEY *
399
d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a)
400
{
401
	return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey,
402
	    bp, a);
403
}
404
405
int
406
i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey)
407
{
408
4
	return ASN1_i2d_bio_of(EVP_PKEY, i2d_PrivateKey, bp, pkey);
409
}
410
411
EVP_PKEY *
412
d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a)
413
{
414
	return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey,
415
	    fp, a);
416
}
417
418
int
419
i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey)
420
{
421
	return ASN1_i2d_fp_of(EVP_PKEY, i2d_PrivateKey, fp, pkey);
422
}
423
424
EVP_PKEY *
425
d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a)
426
{
427
	return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_PUBKEY, bp, a);
428
}
429
430
int
431
i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey)
432
{
433
	return ASN1_i2d_bio_of(EVP_PKEY, i2d_PUBKEY, bp, pkey);
434
}
435
436
int
437
i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey)
438
{
439
	return ASN1_i2d_fp_of(EVP_PKEY, i2d_PUBKEY, fp, pkey);
440
}
441
442
EVP_PKEY *
443
d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a)
444
{
445
	return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_PUBKEY, fp, a);
446
}
447
448
int
449
i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key)
450
{
451
	PKCS8_PRIV_KEY_INFO *p8inf;
452
	int ret;
453
454
	p8inf = EVP_PKEY2PKCS8(key);
455
	if (!p8inf)
456
		return 0;
457
	ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf);
458
	PKCS8_PRIV_KEY_INFO_free(p8inf);
459
	return ret;
460
}
461
462
int
463
i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key)
464
{
465
	PKCS8_PRIV_KEY_INFO *p8inf;
466
	int ret;
467
	p8inf = EVP_PKEY2PKCS8(key);
468
	if (!p8inf)
469
		return 0;
470
	ret = i2d_PKCS8_PRIV_KEY_INFO_fp(fp, p8inf);
471
	PKCS8_PRIV_KEY_INFO_free(p8inf);
472
	return ret;
473
}
474
475
int
476
X509_verify(X509 *a, EVP_PKEY *r)
477
{
478
2354
	if (X509_ALGOR_cmp(a->sig_alg, a->cert_info->signature))
479
		return 0;
480
2354
	return(ASN1_item_verify(&X509_CINF_it, a->sig_alg,
481
1177
	    a->signature, a->cert_info, r));
482
1177
}
483
484
int
485
X509_REQ_verify(X509_REQ *a, EVP_PKEY *r)
486
{
487
18
	return (ASN1_item_verify(&X509_REQ_INFO_it,
488
36
	    a->sig_alg, a->signature, a->req_info, r));
489
}
490
491
int
492
NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r)
493
{
494
4
	return (ASN1_item_verify(&NETSCAPE_SPKAC_it,
495
8
	    a->sig_algor, a->signature, a->spkac, r));
496
}
497
498
int
499
X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
500
{
501
4
	x->cert_info->enc.modified = 1;
502
2
	return (ASN1_item_sign(&X509_CINF_it,
503
2
	    x->cert_info->signature, x->sig_alg, x->signature,
504
2
	    x->cert_info, pkey, md));
505
}
506
507
int
508
X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx)
509
{
510
76
	x->cert_info->enc.modified = 1;
511
38
	return ASN1_item_sign_ctx(&X509_CINF_it,
512
38
	    x->cert_info->signature, x->sig_alg, x->signature,
513
38
	    x->cert_info, ctx);
514
}
515
516
int
517
X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md)
518
{
519
	return (ASN1_item_sign(&X509_REQ_INFO_it,
520
	    x->sig_alg, NULL, x->signature, x->req_info, pkey, md));
521
}
522
523
int
524
X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx)
525
{
526
18
	return ASN1_item_sign_ctx(&X509_REQ_INFO_it,
527
36
	    x->sig_alg, NULL, x->signature, x->req_info, ctx);
528
}
529
530
int
531
X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)
532
{
533
	x->crl->enc.modified = 1;
534
	return(ASN1_item_sign(&X509_CRL_INFO_it, x->crl->sig_alg,
535
	    x->sig_alg, x->signature, x->crl, pkey, md));
536
}
537
538
int
539
X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx)
540
{
541
4
	x->crl->enc.modified = 1;
542
2
	return ASN1_item_sign_ctx(&X509_CRL_INFO_it,
543
2
	    x->crl->sig_alg, x->sig_alg, x->signature, x->crl, ctx);
544
}
545
546
int
547
NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)
548
{
549
2
	return (ASN1_item_sign(&NETSCAPE_SPKAC_it,
550
4
	    x->sig_algor, NULL, x->signature, x->spkac, pkey, md));
551
}
552
553
int
554
X509_pubkey_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
555
    unsigned int *len)
556
{
557
	ASN1_BIT_STRING *key;
558
40
	key = X509_get0_pubkey_bitstr(data);
559
20
	if (!key)
560
		return 0;
561
20
	return EVP_Digest(key->data, key->length, md, len, type, NULL);
562
20
}
563
564
int
565
X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
566
    unsigned int *len)
567
{
568
5232
	return (ASN1_item_digest(&X509_it, type, (char *)data,
569
	    md, len));
570
}
571
572
int
573
X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, unsigned char *md,
574
    unsigned int *len)
575
{
576
16
	return (ASN1_item_digest(&X509_CRL_it, type, (char *)data,
577
	    md, len));
578
}
579
580
int
581
X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, unsigned char *md,
582
    unsigned int *len)
583
{
584
	return (ASN1_item_digest(&X509_REQ_it, type, (char *)data,
585
	    md, len));
586
}
587
588
int
589
X509_NAME_digest(const X509_NAME *data, const EVP_MD *type, unsigned char *md,
590
    unsigned int *len)
591
{
592
40
	return (ASN1_item_digest(&X509_NAME_it, type, (char *)data,
593
	    md, len));
594
}
595
596
int
597
PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
598
    const EVP_MD *type, unsigned char *md, unsigned int *len)
599
{
600
	return(ASN1_item_digest(&PKCS7_ISSUER_AND_SERIAL_it, type,
601
	    (char *)data, md, len));
602
}
603
604
int
605
X509_up_ref(X509 *x)
606
{
607
4784
	int i = CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
608
2392
	return i > 1 ? 1 : 0;
609
}