]>
Commit | Line | Data |
---|---|---|
d02b48c6 | 1 | /* crypto/evp/p_lib.c */ |
58964a49 | 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
d02b48c6 RE |
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 "cryptlib.h" | |
4d94ae00 BM |
61 | #include <openssl/bn.h> |
62 | #include <openssl/err.h> | |
ec577822 BM |
63 | #include <openssl/objects.h> |
64 | #include <openssl/evp.h> | |
65 | #include <openssl/asn1_mac.h> | |
66 | #include <openssl/x509.h> | |
60a938c6 GT |
67 | #include <openssl/rsa.h> |
68 | #include <openssl/dsa.h> | |
69 | #include <openssl/dh.h> | |
d02b48c6 | 70 | |
d02b48c6 | 71 | static void EVP_PKEY_free_it(EVP_PKEY *x); |
bb2297a4 | 72 | |
6b691a5c | 73 | int EVP_PKEY_bits(EVP_PKEY *pkey) |
58964a49 | 74 | { |
4d94ae00 BM |
75 | if (0) |
76 | return 0; | |
cf1b7d96 | 77 | #ifndef OPENSSL_NO_RSA |
4d94ae00 | 78 | else if (pkey->type == EVP_PKEY_RSA) |
58964a49 | 79 | return(BN_num_bits(pkey->pkey.rsa->n)); |
58964a49 | 80 | #endif |
cf1b7d96 | 81 | #ifndef OPENSSL_NO_DSA |
4d94ae00 | 82 | else if (pkey->type == EVP_PKEY_DSA) |
58964a49 | 83 | return(BN_num_bits(pkey->pkey.dsa->p)); |
4d94ae00 | 84 | #endif |
14a7cfb3 BM |
85 | #ifndef OPENSSL_NO_EC |
86 | else if (pkey->type == EVP_PKEY_EC) | |
4d94ae00 BM |
87 | { |
88 | BIGNUM *order = BN_new(); | |
89 | int ret; | |
90 | ||
91 | if (!order) | |
92 | { | |
93 | ERR_clear_error(); | |
94 | return 0; | |
95 | } | |
14a7cfb3 | 96 | if (!EC_GROUP_get_order(pkey->pkey.eckey->group, order, NULL)) |
4d94ae00 BM |
97 | { |
98 | ERR_clear_error(); | |
99 | return 0; | |
100 | } | |
101 | ||
102 | ret = BN_num_bits(order); | |
103 | BN_free(order); | |
104 | return ret; | |
105 | } | |
58964a49 RE |
106 | #endif |
107 | return(0); | |
108 | } | |
109 | ||
6b691a5c | 110 | int EVP_PKEY_size(EVP_PKEY *pkey) |
d02b48c6 | 111 | { |
92dad6cc BL |
112 | if (pkey == NULL) |
113 | return(0); | |
93d9121a | 114 | #ifndef OPENSSL_NO_RSA |
d02b48c6 RE |
115 | if (pkey->type == EVP_PKEY_RSA) |
116 | return(RSA_size(pkey->pkey.rsa)); | |
117 | else | |
118 | #endif | |
cf1b7d96 | 119 | #ifndef OPENSSL_NO_DSA |
d02b48c6 RE |
120 | if (pkey->type == EVP_PKEY_DSA) |
121 | return(DSA_size(pkey->pkey.dsa)); | |
122 | #endif | |
64376cd8 | 123 | #ifndef OPENSSL_NO_ECDSA |
14a7cfb3 BM |
124 | if (pkey->type == EVP_PKEY_EC) |
125 | return(ECDSA_size(pkey->pkey.eckey)); | |
4d94ae00 BM |
126 | #endif |
127 | ||
d02b48c6 RE |
128 | return(0); |
129 | } | |
130 | ||
6b691a5c | 131 | int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode) |
d02b48c6 | 132 | { |
cf1b7d96 | 133 | #ifndef OPENSSL_NO_DSA |
d02b48c6 RE |
134 | if (pkey->type == EVP_PKEY_DSA) |
135 | { | |
bc8a9f1f | 136 | int ret=pkey->save_parameters; |
d02b48c6 RE |
137 | |
138 | if (mode >= 0) | |
139 | pkey->save_parameters=mode; | |
140 | return(ret); | |
141 | } | |
4d94ae00 | 142 | #endif |
5488bb61 BM |
143 | #ifndef OPENSSL_NO_EC |
144 | if (pkey->type == EVP_PKEY_EC) | |
4d94ae00 BM |
145 | { |
146 | int ret = pkey->save_parameters; | |
147 | ||
148 | if (mode >= 0) | |
149 | pkey->save_parameters = mode; | |
150 | return(ret); | |
151 | } | |
d02b48c6 RE |
152 | #endif |
153 | return(0); | |
154 | } | |
155 | ||
a8b72844 | 156 | int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from) |
d02b48c6 RE |
157 | { |
158 | if (to->type != from->type) | |
159 | { | |
160 | EVPerr(EVP_F_EVP_PKEY_COPY_PARAMETERS,EVP_R_DIFFERENT_KEY_TYPES); | |
58964a49 | 161 | goto err; |
d02b48c6 RE |
162 | } |
163 | ||
164 | if (EVP_PKEY_missing_parameters(from)) | |
165 | { | |
657e60fa | 166 | EVPerr(EVP_F_EVP_PKEY_COPY_PARAMETERS,EVP_R_MISSING_PARAMETERS); |
58964a49 | 167 | goto err; |
d02b48c6 | 168 | } |
cf1b7d96 | 169 | #ifndef OPENSSL_NO_DSA |
d02b48c6 RE |
170 | if (to->type == EVP_PKEY_DSA) |
171 | { | |
172 | BIGNUM *a; | |
173 | ||
174 | if ((a=BN_dup(from->pkey.dsa->p)) == NULL) goto err; | |
175 | if (to->pkey.dsa->p != NULL) BN_free(to->pkey.dsa->p); | |
176 | to->pkey.dsa->p=a; | |
177 | ||
178 | if ((a=BN_dup(from->pkey.dsa->q)) == NULL) goto err; | |
179 | if (to->pkey.dsa->q != NULL) BN_free(to->pkey.dsa->q); | |
180 | to->pkey.dsa->q=a; | |
181 | ||
182 | if ((a=BN_dup(from->pkey.dsa->g)) == NULL) goto err; | |
183 | if (to->pkey.dsa->g != NULL) BN_free(to->pkey.dsa->g); | |
184 | to->pkey.dsa->g=a; | |
185 | } | |
4d94ae00 | 186 | #endif |
14a7cfb3 | 187 | #ifndef OPENSSL_NO_EC |
5488bb61 | 188 | if (to->type == EVP_PKEY_EC) |
4d94ae00 | 189 | { |
14a7cfb3 BM |
190 | if (to->pkey.eckey->group != NULL) |
191 | EC_GROUP_free(to->pkey.eckey->group); | |
192 | if ((to->pkey.eckey->group = EC_GROUP_new( | |
193 | EC_GROUP_method_of(from->pkey.eckey->group))) == NULL) | |
194 | goto err; | |
195 | if (!EC_GROUP_copy(to->pkey.eckey->group, | |
196 | from->pkey.eckey->group)) goto err; | |
4d94ae00 | 197 | } |
d02b48c6 RE |
198 | #endif |
199 | return(1); | |
200 | err: | |
201 | return(0); | |
202 | } | |
203 | ||
af0f0f3e | 204 | int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey) |
d02b48c6 | 205 | { |
cf1b7d96 | 206 | #ifndef OPENSSL_NO_DSA |
d02b48c6 RE |
207 | if (pkey->type == EVP_PKEY_DSA) |
208 | { | |
209 | DSA *dsa; | |
210 | ||
211 | dsa=pkey->pkey.dsa; | |
212 | if ((dsa->p == NULL) || (dsa->q == NULL) || (dsa->g == NULL)) | |
213 | return(1); | |
214 | } | |
215 | #endif | |
14a7cfb3 BM |
216 | #ifndef OPENSSL_NO_EC |
217 | if (pkey->type == EVP_PKEY_EC) | |
4d94ae00 | 218 | { |
14a7cfb3 | 219 | if (pkey->pkey.eckey->group == NULL) |
4d94ae00 BM |
220 | return(1); |
221 | } | |
222 | #endif | |
223 | ||
d02b48c6 RE |
224 | return(0); |
225 | } | |
226 | ||
af0f0f3e | 227 | int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b) |
58964a49 | 228 | { |
cf1b7d96 | 229 | #ifndef OPENSSL_NO_DSA |
58964a49 RE |
230 | if ((a->type == EVP_PKEY_DSA) && (b->type == EVP_PKEY_DSA)) |
231 | { | |
232 | if ( BN_cmp(a->pkey.dsa->p,b->pkey.dsa->p) || | |
233 | BN_cmp(a->pkey.dsa->q,b->pkey.dsa->q) || | |
234 | BN_cmp(a->pkey.dsa->g,b->pkey.dsa->g)) | |
235 | return(0); | |
236 | else | |
237 | return(1); | |
238 | } | |
ada0e717 BM |
239 | #endif |
240 | #ifndef OPENSSL_NO_EC | |
241 | if (a->type == EVP_PKEY_EC && b->type == EVP_PKEY_EC) | |
242 | { | |
243 | if (EC_GROUP_cmp(a->pkey.eckey->group, b->pkey.eckey->group, NULL)) | |
244 | return 0; | |
245 | else | |
246 | return 1; | |
247 | } | |
58964a49 RE |
248 | #endif |
249 | return(-1); | |
250 | } | |
251 | ||
af0f0f3e | 252 | int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b) |
e6526fbf RL |
253 | { |
254 | if (a->type != b->type) | |
255 | return -1; | |
256 | ||
7b36590b RL |
257 | if (EVP_PKEY_cmp_parameters(a, b) == 0) |
258 | return 0; | |
a8b72844 | 259 | |
e6526fbf RL |
260 | switch (a->type) |
261 | { | |
262 | #ifndef OPENSSL_NO_RSA | |
263 | case EVP_PKEY_RSA: | |
264 | if (BN_cmp(b->pkey.rsa->n,a->pkey.rsa->n) != 0 | |
265 | || BN_cmp(b->pkey.rsa->e,a->pkey.rsa->e) != 0) | |
266 | return 0; | |
267 | break; | |
268 | #endif | |
269 | #ifndef OPENSSL_NO_DSA | |
270 | case EVP_PKEY_DSA: | |
271 | if (BN_cmp(b->pkey.dsa->pub_key,a->pkey.dsa->pub_key) != 0) | |
272 | return 0; | |
273 | break; | |
274 | #endif | |
275 | #ifndef OPENSSL_NO_EC | |
276 | case EVP_PKEY_EC: | |
277 | { | |
278 | int r = EC_POINT_cmp(b->pkey.eckey->group, | |
279 | b->pkey.eckey->pub_key,a->pkey.eckey->pub_key,NULL); | |
280 | if (r != 0) | |
281 | { | |
282 | if (r == 1) | |
283 | return 0; | |
284 | else | |
285 | return -2; | |
286 | } | |
287 | } | |
288 | break; | |
289 | #endif | |
290 | #ifndef OPENSSL_NO_DH | |
291 | case EVP_PKEY_DH: | |
292 | return -2; | |
293 | #endif | |
294 | default: | |
295 | return -2; | |
296 | } | |
297 | ||
298 | return 1; | |
299 | } | |
300 | ||
6b691a5c | 301 | EVP_PKEY *EVP_PKEY_new(void) |
d02b48c6 RE |
302 | { |
303 | EVP_PKEY *ret; | |
304 | ||
26a3a48d | 305 | ret=(EVP_PKEY *)OPENSSL_malloc(sizeof(EVP_PKEY)); |
d02b48c6 RE |
306 | if (ret == NULL) |
307 | { | |
308 | EVPerr(EVP_F_EVP_PKEY_NEW,ERR_R_MALLOC_FAILURE); | |
309 | return(NULL); | |
310 | } | |
311 | ret->type=EVP_PKEY_NONE; | |
312 | ret->references=1; | |
313 | ret->pkey.ptr=NULL; | |
314 | ret->attributes=NULL; | |
315 | ret->save_parameters=1; | |
316 | return(ret); | |
317 | } | |
318 | ||
6b691a5c | 319 | int EVP_PKEY_assign(EVP_PKEY *pkey, int type, char *key) |
d02b48c6 RE |
320 | { |
321 | if (pkey == NULL) return(0); | |
322 | if (pkey->pkey.ptr != NULL) | |
323 | EVP_PKEY_free_it(pkey); | |
324 | pkey->type=EVP_PKEY_type(type); | |
325 | pkey->save_type=type; | |
326 | pkey->pkey.ptr=key; | |
7f5b6f0f | 327 | return(key != NULL); |
d02b48c6 RE |
328 | } |
329 | ||
cf1b7d96 | 330 | #ifndef OPENSSL_NO_RSA |
c7cb16a8 | 331 | int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, RSA *key) |
52664f50 | 332 | { |
6d3724d3 | 333 | int ret = EVP_PKEY_assign_RSA(pkey, key); |
78435364 | 334 | if(ret) |
6ac4e8bd | 335 | RSA_up_ref(key); |
6d3724d3 | 336 | return ret; |
52664f50 DSH |
337 | } |
338 | ||
c7cb16a8 | 339 | RSA *EVP_PKEY_get1_RSA(EVP_PKEY *pkey) |
f769ce3e DSH |
340 | { |
341 | if(pkey->type != EVP_PKEY_RSA) { | |
c7cb16a8 | 342 | EVPerr(EVP_F_EVP_PKEY_GET1_RSA, EVP_R_EXPECTING_AN_RSA_KEY); |
f769ce3e DSH |
343 | return NULL; |
344 | } | |
6ac4e8bd | 345 | RSA_up_ref(pkey->pkey.rsa); |
f769ce3e DSH |
346 | return pkey->pkey.rsa; |
347 | } | |
348 | #endif | |
349 | ||
cf1b7d96 | 350 | #ifndef OPENSSL_NO_DSA |
c7cb16a8 | 351 | int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, DSA *key) |
52664f50 | 352 | { |
6d3724d3 | 353 | int ret = EVP_PKEY_assign_DSA(pkey, key); |
78435364 | 354 | if(ret) |
6ac4e8bd | 355 | DSA_up_ref(key); |
6d3724d3 | 356 | return ret; |
52664f50 DSH |
357 | } |
358 | ||
c7cb16a8 | 359 | DSA *EVP_PKEY_get1_DSA(EVP_PKEY *pkey) |
f769ce3e DSH |
360 | { |
361 | if(pkey->type != EVP_PKEY_DSA) { | |
c7cb16a8 | 362 | EVPerr(EVP_F_EVP_PKEY_GET1_DSA, EVP_R_EXPECTING_A_DSA_KEY); |
f769ce3e DSH |
363 | return NULL; |
364 | } | |
6ac4e8bd | 365 | DSA_up_ref(pkey->pkey.dsa); |
f769ce3e DSH |
366 | return pkey->pkey.dsa; |
367 | } | |
368 | #endif | |
369 | ||
14a7cfb3 | 370 | #ifndef OPENSSL_NO_EC |
4d94ae00 | 371 | |
14a7cfb3 | 372 | int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, EC_KEY *key) |
4d94ae00 | 373 | { |
14a7cfb3 BM |
374 | int ret = EVP_PKEY_assign_EC_KEY(pkey,key); |
375 | if (ret) CRYPTO_add(&key->references, 1, CRYPTO_LOCK_EC); | |
4d94ae00 BM |
376 | return ret; |
377 | } | |
378 | ||
14a7cfb3 | 379 | EC_KEY *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey) |
4d94ae00 | 380 | { |
14a7cfb3 | 381 | if (pkey->type != EVP_PKEY_EC) |
4d94ae00 | 382 | { |
14a7cfb3 | 383 | EVPerr(EVP_F_EVP_PKEY_GET1_EC_KEY, EVP_R_EXPECTING_A_EC_KEY); |
4d94ae00 BM |
384 | return NULL; |
385 | } | |
14a7cfb3 BM |
386 | CRYPTO_add(&pkey->pkey.eckey->references, 1, CRYPTO_LOCK_EC); |
387 | return pkey->pkey.eckey; | |
4d94ae00 BM |
388 | } |
389 | #endif | |
390 | ||
391 | ||
cf1b7d96 | 392 | #ifndef OPENSSL_NO_DH |
52664f50 | 393 | |
c7cb16a8 | 394 | int EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key) |
52664f50 | 395 | { |
6d3724d3 | 396 | int ret = EVP_PKEY_assign_DH(pkey, key); |
78435364 | 397 | if(ret) |
e815d301 | 398 | DH_up_ref(key); |
6d3724d3 | 399 | return ret; |
52664f50 DSH |
400 | } |
401 | ||
c7cb16a8 | 402 | DH *EVP_PKEY_get1_DH(EVP_PKEY *pkey) |
f769ce3e DSH |
403 | { |
404 | if(pkey->type != EVP_PKEY_DH) { | |
c7cb16a8 | 405 | EVPerr(EVP_F_EVP_PKEY_GET1_DH, EVP_R_EXPECTING_A_DH_KEY); |
f769ce3e DSH |
406 | return NULL; |
407 | } | |
e815d301 | 408 | DH_up_ref(pkey->pkey.dh); |
f769ce3e DSH |
409 | return pkey->pkey.dh; |
410 | } | |
411 | #endif | |
412 | ||
6b691a5c | 413 | int EVP_PKEY_type(int type) |
d02b48c6 RE |
414 | { |
415 | switch (type) | |
416 | { | |
417 | case EVP_PKEY_RSA: | |
418 | case EVP_PKEY_RSA2: | |
419 | return(EVP_PKEY_RSA); | |
420 | case EVP_PKEY_DSA: | |
58964a49 | 421 | case EVP_PKEY_DSA1: |
d02b48c6 RE |
422 | case EVP_PKEY_DSA2: |
423 | case EVP_PKEY_DSA3: | |
58964a49 | 424 | case EVP_PKEY_DSA4: |
d02b48c6 RE |
425 | return(EVP_PKEY_DSA); |
426 | case EVP_PKEY_DH: | |
427 | return(EVP_PKEY_DH); | |
14a7cfb3 BM |
428 | case EVP_PKEY_EC: |
429 | return(EVP_PKEY_EC); | |
d02b48c6 RE |
430 | default: |
431 | return(NID_undef); | |
432 | } | |
433 | } | |
434 | ||
6b691a5c | 435 | void EVP_PKEY_free(EVP_PKEY *x) |
d02b48c6 RE |
436 | { |
437 | int i; | |
438 | ||
439 | if (x == NULL) return; | |
440 | ||
441 | i=CRYPTO_add(&x->references,-1,CRYPTO_LOCK_EVP_PKEY); | |
58964a49 RE |
442 | #ifdef REF_PRINT |
443 | REF_PRINT("EVP_PKEY",x); | |
444 | #endif | |
d02b48c6 RE |
445 | if (i > 0) return; |
446 | #ifdef REF_CHECK | |
447 | if (i < 0) | |
448 | { | |
449 | fprintf(stderr,"EVP_PKEY_free, bad reference count\n"); | |
450 | abort(); | |
451 | } | |
452 | #endif | |
453 | EVP_PKEY_free_it(x); | |
b6995add DSH |
454 | if (x->attributes) |
455 | sk_X509_ATTRIBUTE_pop_free(x->attributes, X509_ATTRIBUTE_free); | |
26a3a48d | 456 | OPENSSL_free(x); |
d02b48c6 RE |
457 | } |
458 | ||
6b691a5c | 459 | static void EVP_PKEY_free_it(EVP_PKEY *x) |
d02b48c6 RE |
460 | { |
461 | switch (x->type) | |
462 | { | |
cf1b7d96 | 463 | #ifndef OPENSSL_NO_RSA |
d02b48c6 RE |
464 | case EVP_PKEY_RSA: |
465 | case EVP_PKEY_RSA2: | |
466 | RSA_free(x->pkey.rsa); | |
467 | break; | |
468 | #endif | |
cf1b7d96 | 469 | #ifndef OPENSSL_NO_DSA |
d02b48c6 RE |
470 | case EVP_PKEY_DSA: |
471 | case EVP_PKEY_DSA2: | |
472 | case EVP_PKEY_DSA3: | |
58964a49 | 473 | case EVP_PKEY_DSA4: |
d02b48c6 RE |
474 | DSA_free(x->pkey.dsa); |
475 | break; | |
476 | #endif | |
14a7cfb3 BM |
477 | #ifndef OPENSSL_NO_EC |
478 | case EVP_PKEY_EC: | |
479 | EC_KEY_free(x->pkey.eckey); | |
4d94ae00 BM |
480 | break; |
481 | #endif | |
cf1b7d96 | 482 | #ifndef OPENSSL_NO_DH |
d02b48c6 RE |
483 | case EVP_PKEY_DH: |
484 | DH_free(x->pkey.dh); | |
485 | break; | |
486 | #endif | |
487 | } | |
488 | } | |
489 |