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