• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* crypto/ec/ec_key.c */
2 /*
3  * Written by Nils Larsch for the OpenSSL project.
4  */
5 /* ====================================================================
6  * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    openssl-core@openssl.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58 /* ====================================================================
59  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
60  * Portions originally developed by SUN MICROSYSTEMS, INC., and
61  * contributed to the OpenSSL project.
62  */
63 
64 #include <string.h>
65 #include "ec_lcl.h"
66 #include <openssl/err.h>
67 #include <string.h>
68 
EC_KEY_new(void)69 EC_KEY *EC_KEY_new(void)
70 	{
71 	EC_KEY *ret;
72 
73 	ret=(EC_KEY *)OPENSSL_malloc(sizeof(EC_KEY));
74 	if (ret == NULL)
75 		{
76 		ECerr(EC_F_EC_KEY_NEW, ERR_R_MALLOC_FAILURE);
77 		return(NULL);
78 		}
79 
80 	ret->version = 1;
81 	ret->group   = NULL;
82 	ret->pub_key = NULL;
83 	ret->priv_key= NULL;
84 	ret->enc_flag= 0;
85 	ret->conv_form = POINT_CONVERSION_UNCOMPRESSED;
86 	ret->references= 1;
87 	ret->method_data = NULL;
88 	return(ret);
89 	}
90 
EC_KEY_new_by_curve_name(int nid)91 EC_KEY *EC_KEY_new_by_curve_name(int nid)
92 	{
93 	EC_KEY *ret = EC_KEY_new();
94 	if (ret == NULL)
95 		return NULL;
96 	ret->group = EC_GROUP_new_by_curve_name(nid);
97 	if (ret->group == NULL)
98 		{
99 		EC_KEY_free(ret);
100 		return NULL;
101 		}
102 	return ret;
103 	}
104 
EC_KEY_free(EC_KEY * r)105 void EC_KEY_free(EC_KEY *r)
106 	{
107 	int i;
108 
109 	if (r == NULL) return;
110 
111 	i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_EC);
112 #ifdef REF_PRINT
113 	REF_PRINT("EC_KEY",r);
114 #endif
115 	if (i > 0) return;
116 #ifdef REF_CHECK
117 	if (i < 0)
118 		{
119 		fprintf(stderr,"EC_KEY_free, bad reference count\n");
120 		abort();
121 		}
122 #endif
123 
124 	if (r->group    != NULL)
125 		EC_GROUP_free(r->group);
126 	if (r->pub_key  != NULL)
127 		EC_POINT_free(r->pub_key);
128 	if (r->priv_key != NULL)
129 		BN_clear_free(r->priv_key);
130 
131 	EC_EX_DATA_free_all_data(&r->method_data);
132 
133 	OPENSSL_cleanse((void *)r, sizeof(EC_KEY));
134 
135 	OPENSSL_free(r);
136 	}
137 
EC_KEY_copy(EC_KEY * dest,const EC_KEY * src)138 EC_KEY *EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
139 	{
140 	EC_EXTRA_DATA *d;
141 
142 	if (dest == NULL || src == NULL)
143 		{
144 		ECerr(EC_F_EC_KEY_COPY, ERR_R_PASSED_NULL_PARAMETER);
145 		return NULL;
146 		}
147 	/* copy the parameters */
148 	if (src->group)
149 		{
150 		const EC_METHOD *meth = EC_GROUP_method_of(src->group);
151 		/* clear the old group */
152 		if (dest->group)
153 			EC_GROUP_free(dest->group);
154 		dest->group = EC_GROUP_new(meth);
155 		if (dest->group == NULL)
156 			return NULL;
157 		if (!EC_GROUP_copy(dest->group, src->group))
158 			return NULL;
159 		}
160 	/*  copy the public key */
161 	if (src->pub_key && src->group)
162 		{
163 		if (dest->pub_key)
164 			EC_POINT_free(dest->pub_key);
165 		dest->pub_key = EC_POINT_new(src->group);
166 		if (dest->pub_key == NULL)
167 			return NULL;
168 		if (!EC_POINT_copy(dest->pub_key, src->pub_key))
169 			return NULL;
170 		}
171 	/* copy the private key */
172 	if (src->priv_key)
173 		{
174 		if (dest->priv_key == NULL)
175 			{
176 			dest->priv_key = BN_new();
177 			if (dest->priv_key == NULL)
178 				return NULL;
179 			}
180 		if (!BN_copy(dest->priv_key, src->priv_key))
181 			return NULL;
182 		}
183 	/* copy method/extra data */
184 	EC_EX_DATA_free_all_data(&dest->method_data);
185 
186 	for (d = src->method_data; d != NULL; d = d->next)
187 		{
188 		void *t = d->dup_func(d->data);
189 
190 		if (t == NULL)
191 			return 0;
192 		if (!EC_EX_DATA_set_data(&dest->method_data, t, d->dup_func, d->free_func, d->clear_free_func))
193 			return 0;
194 		}
195 
196 	/* copy the rest */
197 	dest->enc_flag  = src->enc_flag;
198 	dest->conv_form = src->conv_form;
199 	dest->version   = src->version;
200 
201 	return dest;
202 	}
203 
EC_KEY_dup(const EC_KEY * ec_key)204 EC_KEY *EC_KEY_dup(const EC_KEY *ec_key)
205 	{
206 	EC_KEY *ret = EC_KEY_new();
207 	if (ret == NULL)
208 		return NULL;
209 	if (EC_KEY_copy(ret, ec_key) == NULL)
210 		{
211 		EC_KEY_free(ret);
212 		return NULL;
213 		}
214 	return ret;
215 	}
216 
EC_KEY_up_ref(EC_KEY * r)217 int EC_KEY_up_ref(EC_KEY *r)
218 	{
219 	int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_EC);
220 #ifdef REF_PRINT
221 	REF_PRINT("EC_KEY",r);
222 #endif
223 #ifdef REF_CHECK
224 	if (i < 2)
225 		{
226 		fprintf(stderr, "EC_KEY_up, bad reference count\n");
227 		abort();
228 		}
229 #endif
230 	return ((i > 1) ? 1 : 0);
231 	}
232 
EC_KEY_generate_key(EC_KEY * eckey)233 int EC_KEY_generate_key(EC_KEY *eckey)
234 	{
235 	int	ok = 0;
236 	BN_CTX	*ctx = NULL;
237 	BIGNUM	*priv_key = NULL, *order = NULL;
238 	EC_POINT *pub_key = NULL;
239 
240 	if (!eckey || !eckey->group)
241 		{
242 		ECerr(EC_F_EC_KEY_GENERATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
243 		return 0;
244 		}
245 
246 	if ((order = BN_new()) == NULL) goto err;
247 	if ((ctx = BN_CTX_new()) == NULL) goto err;
248 
249 	if (eckey->priv_key == NULL)
250 		{
251 		priv_key = BN_new();
252 		if (priv_key == NULL)
253 			goto err;
254 		}
255 	else
256 		priv_key = eckey->priv_key;
257 
258 	if (!EC_GROUP_get_order(eckey->group, order, ctx))
259 		goto err;
260 
261 	do
262 		if (!BN_rand_range(priv_key, order))
263 			goto err;
264 	while (BN_is_zero(priv_key));
265 
266 	if (eckey->pub_key == NULL)
267 		{
268 		pub_key = EC_POINT_new(eckey->group);
269 		if (pub_key == NULL)
270 			goto err;
271 		}
272 	else
273 		pub_key = eckey->pub_key;
274 
275 	if (!EC_POINT_mul(eckey->group, pub_key, priv_key, NULL, NULL, ctx))
276 		goto err;
277 
278 	eckey->priv_key = priv_key;
279 	eckey->pub_key  = pub_key;
280 
281 	ok=1;
282 
283 err:
284 	if (order)
285 		BN_free(order);
286 	if (pub_key  != NULL && eckey->pub_key  == NULL)
287 		EC_POINT_free(pub_key);
288 	if (priv_key != NULL && eckey->priv_key == NULL)
289 		BN_free(priv_key);
290 	if (ctx != NULL)
291 		BN_CTX_free(ctx);
292 	return(ok);
293 	}
294 
EC_KEY_check_key(const EC_KEY * eckey)295 int EC_KEY_check_key(const EC_KEY *eckey)
296 	{
297 	int	ok   = 0;
298 	BN_CTX	*ctx = NULL;
299 	const BIGNUM	*order  = NULL;
300 	EC_POINT *point = NULL;
301 
302 	if (!eckey || !eckey->group || !eckey->pub_key)
303 		{
304 		ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_PASSED_NULL_PARAMETER);
305 		return 0;
306 		}
307 
308 	if ((ctx = BN_CTX_new()) == NULL)
309 		goto err;
310 	if ((point = EC_POINT_new(eckey->group)) == NULL)
311 		goto err;
312 
313 	/* testing whether the pub_key is on the elliptic curve */
314 	if (!EC_POINT_is_on_curve(eckey->group, eckey->pub_key, ctx))
315 		{
316 		ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_POINT_IS_NOT_ON_CURVE);
317 		goto err;
318 		}
319 	/* testing whether pub_key * order is the point at infinity */
320 	order = &eckey->group->order;
321 	if (BN_is_zero(order))
322 		{
323 		ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_GROUP_ORDER);
324 		goto err;
325 		}
326 	if (!EC_POINT_mul(eckey->group, point, NULL, eckey->pub_key, order, ctx))
327 		{
328 		ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB);
329 		goto err;
330 		}
331 	if (!EC_POINT_is_at_infinity(eckey->group, point))
332 		{
333 		ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_WRONG_ORDER);
334 		goto err;
335 		}
336 	/* in case the priv_key is present :
337 	 * check if generator * priv_key == pub_key
338 	 */
339 	if (eckey->priv_key)
340 		{
341 		if (BN_cmp(eckey->priv_key, order) >= 0)
342 			{
343 			ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_WRONG_ORDER);
344 			goto err;
345 			}
346 		if (!EC_POINT_mul(eckey->group, point, eckey->priv_key,
347 			NULL, NULL, ctx))
348 			{
349 			ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB);
350 			goto err;
351 			}
352 		if (EC_POINT_cmp(eckey->group, point, eckey->pub_key,
353 			ctx) != 0)
354 			{
355 			ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_PRIVATE_KEY);
356 			goto err;
357 			}
358 		}
359 	ok = 1;
360 err:
361 	if (ctx   != NULL)
362 		BN_CTX_free(ctx);
363 	if (point != NULL)
364 		EC_POINT_free(point);
365 	return(ok);
366 	}
367 
EC_KEY_get0_group(const EC_KEY * key)368 const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key)
369 	{
370 	return key->group;
371 	}
372 
EC_KEY_set_group(EC_KEY * key,const EC_GROUP * group)373 int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group)
374 	{
375 	if (key->group != NULL)
376 		EC_GROUP_free(key->group);
377 	key->group = EC_GROUP_dup(group);
378 	return (key->group == NULL) ? 0 : 1;
379 	}
380 
EC_KEY_get0_private_key(const EC_KEY * key)381 const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key)
382 	{
383 	return key->priv_key;
384 	}
385 
EC_KEY_set_private_key(EC_KEY * key,const BIGNUM * priv_key)386 int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key)
387 	{
388 	if (key->priv_key)
389 		BN_clear_free(key->priv_key);
390 	key->priv_key = BN_dup(priv_key);
391 	return (key->priv_key == NULL) ? 0 : 1;
392 	}
393 
EC_KEY_get0_public_key(const EC_KEY * key)394 const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key)
395 	{
396 	return key->pub_key;
397 	}
398 
EC_KEY_set_public_key(EC_KEY * key,const EC_POINT * pub_key)399 int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub_key)
400 	{
401 	if (key->pub_key != NULL)
402 		EC_POINT_free(key->pub_key);
403 	key->pub_key = EC_POINT_dup(pub_key, key->group);
404 	return (key->pub_key == NULL) ? 0 : 1;
405 	}
406 
EC_KEY_get_enc_flags(const EC_KEY * key)407 unsigned int EC_KEY_get_enc_flags(const EC_KEY *key)
408 	{
409 	return key->enc_flag;
410 	}
411 
EC_KEY_set_enc_flags(EC_KEY * key,unsigned int flags)412 void EC_KEY_set_enc_flags(EC_KEY *key, unsigned int flags)
413 	{
414 	key->enc_flag = flags;
415 	}
416 
EC_KEY_get_conv_form(const EC_KEY * key)417 point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key)
418 	{
419 	return key->conv_form;
420 	}
421 
EC_KEY_set_conv_form(EC_KEY * key,point_conversion_form_t cform)422 void EC_KEY_set_conv_form(EC_KEY *key, point_conversion_form_t cform)
423 	{
424 	key->conv_form = cform;
425 	if (key->group != NULL)
426 		EC_GROUP_set_point_conversion_form(key->group, cform);
427 	}
428 
EC_KEY_get_key_method_data(EC_KEY * key,void * (* dup_func)(void *),void (* free_func)(void *),void (* clear_free_func)(void *))429 void *EC_KEY_get_key_method_data(EC_KEY *key,
430 	void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *))
431 	{
432 	return EC_EX_DATA_get_data(key->method_data, dup_func, free_func, clear_free_func);
433 	}
434 
EC_KEY_insert_key_method_data(EC_KEY * key,void * data,void * (* dup_func)(void *),void (* free_func)(void *),void (* clear_free_func)(void *))435 void EC_KEY_insert_key_method_data(EC_KEY *key, void *data,
436 	void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *))
437 	{
438 	EC_EXTRA_DATA *ex_data;
439 	CRYPTO_w_lock(CRYPTO_LOCK_EC);
440 	ex_data = EC_EX_DATA_get_data(key->method_data, dup_func, free_func, clear_free_func);
441 	if (ex_data == NULL)
442 		EC_EX_DATA_set_data(&key->method_data, data, dup_func, free_func, clear_free_func);
443 	CRYPTO_w_unlock(CRYPTO_LOCK_EC);
444 	}
445 
EC_KEY_set_asn1_flag(EC_KEY * key,int flag)446 void EC_KEY_set_asn1_flag(EC_KEY *key, int flag)
447 	{
448 	if (key->group != NULL)
449 		EC_GROUP_set_asn1_flag(key->group, flag);
450 	}
451 
EC_KEY_precompute_mult(EC_KEY * key,BN_CTX * ctx)452 int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx)
453 	{
454 	if (key->group == NULL)
455 		return 0;
456 	return EC_GROUP_precompute_mult(key->group, ctx);
457 	}
458