(oops) Apologies all, that last header-cleanup commit was from the wrong
[openssl.git] / crypto / evp / p_lib.c
1 /* crypto/evp/p_lib.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 "cryptlib.h"
61 #include <openssl/bn.h>
62 #include <openssl/err.h>
63 #include <openssl/objects.h>
64 #include <openssl/evp.h>
65 #include <openssl/asn1_mac.h>
66 #include <openssl/x509.h>
67 #include <openssl/rsa.h>
68 #include <openssl/dsa.h>
69 #include <openssl/dh.h>
70
71 static void EVP_PKEY_free_it(EVP_PKEY *x);
72
73 int EVP_PKEY_bits(EVP_PKEY *pkey)
74         {
75         if (0)
76                 return 0;
77 #ifndef OPENSSL_NO_RSA
78         else if (pkey->type == EVP_PKEY_RSA)
79                 return(BN_num_bits(pkey->pkey.rsa->n));
80 #endif
81 #ifndef OPENSSL_NO_DSA
82         else if (pkey->type == EVP_PKEY_DSA)
83                 return(BN_num_bits(pkey->pkey.dsa->p));
84 #endif
85 #ifndef OPENSSL_NO_EC
86         else if (pkey->type == EVP_PKEY_EC)
87                 {
88                 BIGNUM *order = BN_new();
89                 int ret;
90
91                 if (!order)
92                         {
93                         ERR_clear_error();
94                         return 0;
95                         }
96                 if (!EC_GROUP_get_order(pkey->pkey.eckey->group, order, NULL))
97                         {
98                         ERR_clear_error();
99                         return 0;
100                         }
101
102                 ret = BN_num_bits(order);
103                 BN_free(order);
104                 return ret;
105                 }
106 #endif
107         return(0);
108         }
109
110 int EVP_PKEY_size(EVP_PKEY *pkey)
111         {
112         if (pkey == NULL)
113                 return(0);
114 #ifndef OPENSSL_NO_RSA
115         if (pkey->type == EVP_PKEY_RSA)
116                 return(RSA_size(pkey->pkey.rsa));
117         else
118 #endif
119 #ifndef OPENSSL_NO_DSA
120                 if (pkey->type == EVP_PKEY_DSA)
121                 return(DSA_size(pkey->pkey.dsa));
122 #endif
123 #ifndef OPENSSL_NO_ECDSA
124                 if (pkey->type == EVP_PKEY_EC)
125                 return(ECDSA_size(pkey->pkey.eckey));
126 #endif
127
128         return(0);
129         }
130
131 int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode)
132         {
133 #ifndef OPENSSL_NO_DSA
134         if (pkey->type == EVP_PKEY_DSA)
135                 {
136                 int ret=pkey->save_parameters;
137
138                 if (mode >= 0)
139                         pkey->save_parameters=mode;
140                 return(ret);
141                 }
142 #endif
143 #ifndef OPENSSL_NO_EC
144         if (pkey->type == EVP_PKEY_EC)
145                 {
146                 int ret = pkey->save_parameters;
147
148                 if (mode >= 0)
149                         pkey->save_parameters = mode;
150                 return(ret);
151                 }
152 #endif
153         return(0);
154         }
155
156 int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
157         {
158         if (to->type != from->type)
159                 {
160                 EVPerr(EVP_F_EVP_PKEY_COPY_PARAMETERS,EVP_R_DIFFERENT_KEY_TYPES);
161                 goto err;
162                 }
163
164         if (EVP_PKEY_missing_parameters(from))
165                 {
166                 EVPerr(EVP_F_EVP_PKEY_COPY_PARAMETERS,EVP_R_MISSING_PARAMETERS);
167                 goto err;
168                 }
169 #ifndef OPENSSL_NO_DSA
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                 }
186 #endif
187 #ifndef OPENSSL_NO_EC
188         if (to->type == EVP_PKEY_EC)
189                 {
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;
197                 }
198 #endif
199         return(1);
200 err:
201         return(0);
202         }
203
204 int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey)
205         {
206 #ifndef OPENSSL_NO_DSA
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
216 #ifndef OPENSSL_NO_EC
217         if (pkey->type == EVP_PKEY_EC)
218                 {
219                 if (pkey->pkey.eckey->group == NULL)
220                         return(1);
221                 }
222 #endif
223
224         return(0);
225         }
226
227 int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b)
228         {
229 #ifndef OPENSSL_NO_DSA
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                 }
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                 }
248 #endif
249         return(-1);
250         }
251
252 int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
253         {
254         if (a->type != b->type)
255                 return -1;
256
257         if (EVP_PKEY_cmp_parameters(a, b) == 0)
258                 return 0;
259
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
301 EVP_PKEY *EVP_PKEY_new(void)
302         {
303         EVP_PKEY *ret;
304
305         ret=(EVP_PKEY *)OPENSSL_malloc(sizeof(EVP_PKEY));
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
319 int EVP_PKEY_assign(EVP_PKEY *pkey, int type, char *key)
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;
327         return(key != NULL);
328         }
329
330 #ifndef OPENSSL_NO_RSA
331 int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, RSA *key)
332 {
333         int ret = EVP_PKEY_assign_RSA(pkey, key);
334         if(ret)
335                 RSA_up_ref(key);
336         return ret;
337 }
338
339 RSA *EVP_PKEY_get1_RSA(EVP_PKEY *pkey)
340         {
341         if(pkey->type != EVP_PKEY_RSA) {
342                 EVPerr(EVP_F_EVP_PKEY_GET1_RSA, EVP_R_EXPECTING_AN_RSA_KEY);
343                 return NULL;
344         }
345         RSA_up_ref(pkey->pkey.rsa);
346         return pkey->pkey.rsa;
347 }
348 #endif
349
350 #ifndef OPENSSL_NO_DSA
351 int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, DSA *key)
352 {
353         int ret = EVP_PKEY_assign_DSA(pkey, key);
354         if(ret)
355                 DSA_up_ref(key);
356         return ret;
357 }
358
359 DSA *EVP_PKEY_get1_DSA(EVP_PKEY *pkey)
360         {
361         if(pkey->type != EVP_PKEY_DSA) {
362                 EVPerr(EVP_F_EVP_PKEY_GET1_DSA, EVP_R_EXPECTING_A_DSA_KEY);
363                 return NULL;
364         }
365         DSA_up_ref(pkey->pkey.dsa);
366         return pkey->pkey.dsa;
367 }
368 #endif
369
370 #ifndef OPENSSL_NO_EC
371
372 int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, EC_KEY *key)
373 {
374         int ret = EVP_PKEY_assign_EC_KEY(pkey,key);
375         if (ret) CRYPTO_add(&key->references, 1, CRYPTO_LOCK_EC);
376                 return ret;
377 }
378
379 EC_KEY *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey)
380 {
381         if (pkey->type != EVP_PKEY_EC)
382         {
383                 EVPerr(EVP_F_EVP_PKEY_GET1_EC_KEY, EVP_R_EXPECTING_A_EC_KEY);
384                 return NULL;
385         }
386         CRYPTO_add(&pkey->pkey.eckey->references, 1, CRYPTO_LOCK_EC);
387         return pkey->pkey.eckey;
388 }
389 #endif
390
391
392 #ifndef OPENSSL_NO_DH
393
394 int EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key)
395 {
396         int ret = EVP_PKEY_assign_DH(pkey, key);
397         if(ret)
398                 DH_up_ref(key);
399         return ret;
400 }
401
402 DH *EVP_PKEY_get1_DH(EVP_PKEY *pkey)
403         {
404         if(pkey->type != EVP_PKEY_DH) {
405                 EVPerr(EVP_F_EVP_PKEY_GET1_DH, EVP_R_EXPECTING_A_DH_KEY);
406                 return NULL;
407         }
408         DH_up_ref(pkey->pkey.dh);
409         return pkey->pkey.dh;
410 }
411 #endif
412
413 int EVP_PKEY_type(int type)
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:
421         case EVP_PKEY_DSA1:
422         case EVP_PKEY_DSA2:
423         case EVP_PKEY_DSA3:
424         case EVP_PKEY_DSA4:
425                 return(EVP_PKEY_DSA);
426         case EVP_PKEY_DH:
427                 return(EVP_PKEY_DH);
428         case EVP_PKEY_EC:
429                 return(EVP_PKEY_EC);
430         default:
431                 return(NID_undef);
432                 }
433         }
434
435 void EVP_PKEY_free(EVP_PKEY *x)
436         {
437         int i;
438
439         if (x == NULL) return;
440
441         i=CRYPTO_add(&x->references,-1,CRYPTO_LOCK_EVP_PKEY);
442 #ifdef REF_PRINT
443         REF_PRINT("EVP_PKEY",x);
444 #endif
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);
454         OPENSSL_free(x);
455         }
456
457 static void EVP_PKEY_free_it(EVP_PKEY *x)
458         {
459         switch (x->type)
460                 {
461 #ifndef OPENSSL_NO_RSA
462         case EVP_PKEY_RSA:
463         case EVP_PKEY_RSA2:
464                 RSA_free(x->pkey.rsa);
465                 break;
466 #endif
467 #ifndef OPENSSL_NO_DSA
468         case EVP_PKEY_DSA:
469         case EVP_PKEY_DSA2:
470         case EVP_PKEY_DSA3:
471         case EVP_PKEY_DSA4:
472                 DSA_free(x->pkey.dsa);
473                 break;
474 #endif
475 #ifndef OPENSSL_NO_EC
476         case EVP_PKEY_EC:
477                 EC_KEY_free(x->pkey.eckey);
478                 break;
479 #endif
480 #ifndef OPENSSL_NO_DH
481         case EVP_PKEY_DH:
482                 DH_free(x->pkey.dh);
483                 break;
484 #endif
485                 }
486         }
487