summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/ec/ec_asn1.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/ec/ec_asn1.c')
-rw-r--r--src/lib/libcrypto/ec/ec_asn1.c1618
1 files changed, 0 insertions, 1618 deletions
diff --git a/src/lib/libcrypto/ec/ec_asn1.c b/src/lib/libcrypto/ec/ec_asn1.c
deleted file mode 100644
index 3234e7a6f2..0000000000
--- a/src/lib/libcrypto/ec/ec_asn1.c
+++ /dev/null
@@ -1,1618 +0,0 @@
1/* $OpenBSD: ec_asn1.c,v 1.22 2016/03/20 16:50:29 krw Exp $ */
2/*
3 * Written by Nils Larsch for the OpenSSL project.
4 */
5/* ====================================================================
6 * Copyright (c) 2000-2003 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 * licensing@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#include <string.h>
60
61#include <openssl/opensslconf.h>
62
63#include "ec_lcl.h"
64#include <openssl/err.h>
65#include <openssl/asn1t.h>
66#include <openssl/objects.h>
67
68int
69EC_GROUP_get_basis_type(const EC_GROUP * group)
70{
71 int i = 0;
72
73 if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) !=
74 NID_X9_62_characteristic_two_field)
75 /* everything else is currently not supported */
76 return 0;
77
78 while (group->poly[i] != 0)
79 i++;
80
81 if (i == 4)
82 return NID_X9_62_ppBasis;
83 else if (i == 2)
84 return NID_X9_62_tpBasis;
85 else
86 /* everything else is currently not supported */
87 return 0;
88}
89#ifndef OPENSSL_NO_EC2M
90int
91EC_GROUP_get_trinomial_basis(const EC_GROUP * group, unsigned int *k)
92{
93 if (group == NULL)
94 return 0;
95
96 if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) !=
97 NID_X9_62_characteristic_two_field
98 || !((group->poly[0] != 0) && (group->poly[1] != 0) && (group->poly[2] == 0))) {
99 ECerr(EC_F_EC_GROUP_GET_TRINOMIAL_BASIS, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
100 return 0;
101 }
102 if (k)
103 *k = group->poly[1];
104
105 return 1;
106}
107int
108EC_GROUP_get_pentanomial_basis(const EC_GROUP * group, unsigned int *k1,
109 unsigned int *k2, unsigned int *k3)
110{
111 if (group == NULL)
112 return 0;
113
114 if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) !=
115 NID_X9_62_characteristic_two_field
116 || !((group->poly[0] != 0) && (group->poly[1] != 0) && (group->poly[2] != 0) && (group->poly[3] != 0) && (group->poly[4] == 0))) {
117 ECerr(EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
118 return 0;
119 }
120 if (k1)
121 *k1 = group->poly[3];
122 if (k2)
123 *k2 = group->poly[2];
124 if (k3)
125 *k3 = group->poly[1];
126
127 return 1;
128}
129#endif
130
131
132/* some structures needed for the asn1 encoding */
133typedef struct x9_62_pentanomial_st {
134 long k1;
135 long k2;
136 long k3;
137} X9_62_PENTANOMIAL;
138
139typedef struct x9_62_characteristic_two_st {
140 long m;
141 ASN1_OBJECT *type;
142 union {
143 char *ptr;
144 /* NID_X9_62_onBasis */
145 ASN1_NULL *onBasis;
146 /* NID_X9_62_tpBasis */
147 ASN1_INTEGER *tpBasis;
148 /* NID_X9_62_ppBasis */
149 X9_62_PENTANOMIAL *ppBasis;
150 /* anything else */
151 ASN1_TYPE *other;
152 } p;
153} X9_62_CHARACTERISTIC_TWO;
154
155typedef struct x9_62_fieldid_st {
156 ASN1_OBJECT *fieldType;
157 union {
158 char *ptr;
159 /* NID_X9_62_prime_field */
160 ASN1_INTEGER *prime;
161 /* NID_X9_62_characteristic_two_field */
162 X9_62_CHARACTERISTIC_TWO *char_two;
163 /* anything else */
164 ASN1_TYPE *other;
165 } p;
166} X9_62_FIELDID;
167
168typedef struct x9_62_curve_st {
169 ASN1_OCTET_STRING *a;
170 ASN1_OCTET_STRING *b;
171 ASN1_BIT_STRING *seed;
172} X9_62_CURVE;
173
174typedef struct ec_parameters_st {
175 long version;
176 X9_62_FIELDID *fieldID;
177 X9_62_CURVE *curve;
178 ASN1_OCTET_STRING *base;
179 ASN1_INTEGER *order;
180 ASN1_INTEGER *cofactor;
181} ECPARAMETERS;
182
183struct ecpk_parameters_st {
184 int type;
185 union {
186 ASN1_OBJECT *named_curve;
187 ECPARAMETERS *parameters;
188 ASN1_NULL *implicitlyCA;
189 } value;
190} /* ECPKPARAMETERS */ ;
191
192/* SEC1 ECPrivateKey */
193typedef struct ec_privatekey_st {
194 long version;
195 ASN1_OCTET_STRING *privateKey;
196 ECPKPARAMETERS *parameters;
197 ASN1_BIT_STRING *publicKey;
198} EC_PRIVATEKEY;
199
200/* the OpenSSL ASN.1 definitions */
201static const ASN1_TEMPLATE X9_62_PENTANOMIAL_seq_tt[] = {
202 {
203 .flags = 0,
204 .tag = 0,
205 .offset = offsetof(X9_62_PENTANOMIAL, k1),
206 .field_name = "k1",
207 .item = &LONG_it,
208 },
209 {
210 .flags = 0,
211 .tag = 0,
212 .offset = offsetof(X9_62_PENTANOMIAL, k2),
213 .field_name = "k2",
214 .item = &LONG_it,
215 },
216 {
217 .flags = 0,
218 .tag = 0,
219 .offset = offsetof(X9_62_PENTANOMIAL, k3),
220 .field_name = "k3",
221 .item = &LONG_it,
222 },
223};
224
225const ASN1_ITEM X9_62_PENTANOMIAL_it = {
226 .itype = ASN1_ITYPE_SEQUENCE,
227 .utype = V_ASN1_SEQUENCE,
228 .templates = X9_62_PENTANOMIAL_seq_tt,
229 .tcount = sizeof(X9_62_PENTANOMIAL_seq_tt) / sizeof(ASN1_TEMPLATE),
230 .funcs = NULL,
231 .size = sizeof(X9_62_PENTANOMIAL),
232 .sname = "X9_62_PENTANOMIAL",
233};
234
235X9_62_PENTANOMIAL *X9_62_PENTANOMIAL_new(void);
236void X9_62_PENTANOMIAL_free(X9_62_PENTANOMIAL *a);
237
238X9_62_PENTANOMIAL *
239X9_62_PENTANOMIAL_new(void)
240{
241 return (X9_62_PENTANOMIAL*)ASN1_item_new(&X9_62_PENTANOMIAL_it);
242}
243
244void
245X9_62_PENTANOMIAL_free(X9_62_PENTANOMIAL *a)
246{
247 ASN1_item_free((ASN1_VALUE *)a, &X9_62_PENTANOMIAL_it);
248}
249
250static const ASN1_TEMPLATE char_two_def_tt = {
251 .flags = 0,
252 .tag = 0,
253 .offset = offsetof(X9_62_CHARACTERISTIC_TWO, p.other),
254 .field_name = "p.other",
255 .item = &ASN1_ANY_it,
256};
257
258static const ASN1_ADB_TABLE X9_62_CHARACTERISTIC_TWO_adbtbl[] = {
259 {
260 .value = NID_X9_62_onBasis,
261 .tt = {
262 .flags = 0,
263 .tag = 0,
264 .offset = offsetof(X9_62_CHARACTERISTIC_TWO, p.onBasis),
265 .field_name = "p.onBasis",
266 .item = &ASN1_NULL_it,
267 },
268
269 },
270 {
271 .value = NID_X9_62_tpBasis,
272 .tt = {
273 .flags = 0,
274 .tag = 0,
275 .offset = offsetof(X9_62_CHARACTERISTIC_TWO, p.tpBasis),
276 .field_name = "p.tpBasis",
277 .item = &ASN1_INTEGER_it,
278 },
279
280 },
281 {
282 .value = NID_X9_62_ppBasis,
283 .tt = {
284 .flags = 0,
285 .tag = 0,
286 .offset = offsetof(X9_62_CHARACTERISTIC_TWO, p.ppBasis),
287 .field_name = "p.ppBasis",
288 .item = &X9_62_PENTANOMIAL_it,
289 },
290
291 },
292};
293
294static const ASN1_ADB X9_62_CHARACTERISTIC_TWO_adb = {
295 .flags = 0,
296 .offset = offsetof(X9_62_CHARACTERISTIC_TWO, type),
297 .app_items = 0,
298 .tbl = X9_62_CHARACTERISTIC_TWO_adbtbl,
299 .tblcount = sizeof(X9_62_CHARACTERISTIC_TWO_adbtbl) / sizeof(ASN1_ADB_TABLE),
300 .default_tt = &char_two_def_tt,
301 .null_tt = NULL,
302};
303
304static const ASN1_TEMPLATE X9_62_CHARACTERISTIC_TWO_seq_tt[] = {
305 {
306 .flags = 0,
307 .tag = 0,
308 .offset = offsetof(X9_62_CHARACTERISTIC_TWO, m),
309 .field_name = "m",
310 .item = &LONG_it,
311 },
312 {
313 .flags = 0,
314 .tag = 0,
315 .offset = offsetof(X9_62_CHARACTERISTIC_TWO, type),
316 .field_name = "type",
317 .item = &ASN1_OBJECT_it,
318 },
319 {
320 .flags = ASN1_TFLG_ADB_OID,
321 .tag = -1,
322 .offset = 0,
323 .field_name = "X9_62_CHARACTERISTIC_TWO",
324 .item = (const ASN1_ITEM *)&X9_62_CHARACTERISTIC_TWO_adb,
325 },
326};
327
328const ASN1_ITEM X9_62_CHARACTERISTIC_TWO_it = {
329 .itype = ASN1_ITYPE_SEQUENCE,
330 .utype = V_ASN1_SEQUENCE,
331 .templates = X9_62_CHARACTERISTIC_TWO_seq_tt,
332 .tcount = sizeof(X9_62_CHARACTERISTIC_TWO_seq_tt) / sizeof(ASN1_TEMPLATE),
333 .funcs = NULL,
334 .size = sizeof(X9_62_CHARACTERISTIC_TWO),
335 .sname = "X9_62_CHARACTERISTIC_TWO",
336};
337X9_62_CHARACTERISTIC_TWO *X9_62_CHARACTERISTIC_TWO_new(void);
338void X9_62_CHARACTERISTIC_TWO_free(X9_62_CHARACTERISTIC_TWO *a);
339
340X9_62_CHARACTERISTIC_TWO *
341X9_62_CHARACTERISTIC_TWO_new(void)
342{
343 return (X9_62_CHARACTERISTIC_TWO*)ASN1_item_new(&X9_62_CHARACTERISTIC_TWO_it);
344}
345
346void
347X9_62_CHARACTERISTIC_TWO_free(X9_62_CHARACTERISTIC_TWO *a)
348{
349 ASN1_item_free((ASN1_VALUE *)a, &X9_62_CHARACTERISTIC_TWO_it);
350}
351static const ASN1_TEMPLATE fieldID_def_tt = {
352 .flags = 0,
353 .tag = 0,
354 .offset = offsetof(X9_62_FIELDID, p.other),
355 .field_name = "p.other",
356 .item = &ASN1_ANY_it,
357};
358
359static const ASN1_ADB_TABLE X9_62_FIELDID_adbtbl[] = {
360 {
361 .value = NID_X9_62_prime_field,
362 .tt = {
363 .flags = 0,
364 .tag = 0,
365 .offset = offsetof(X9_62_FIELDID, p.prime),
366 .field_name = "p.prime",
367 .item = &ASN1_INTEGER_it,
368 },
369
370 },
371 {
372 .value = NID_X9_62_characteristic_two_field,
373 .tt = {
374 .flags = 0,
375 .tag = 0,
376 .offset = offsetof(X9_62_FIELDID, p.char_two),
377 .field_name = "p.char_two",
378 .item = &X9_62_CHARACTERISTIC_TWO_it,
379 },
380
381 },
382};
383
384static const ASN1_ADB X9_62_FIELDID_adb = {
385 .flags = 0,
386 .offset = offsetof(X9_62_FIELDID, fieldType),
387 .app_items = 0,
388 .tbl = X9_62_FIELDID_adbtbl,
389 .tblcount = sizeof(X9_62_FIELDID_adbtbl) / sizeof(ASN1_ADB_TABLE),
390 .default_tt = &fieldID_def_tt,
391 .null_tt = NULL,
392};
393
394static const ASN1_TEMPLATE X9_62_FIELDID_seq_tt[] = {
395 {
396 .flags = 0,
397 .tag = 0,
398 .offset = offsetof(X9_62_FIELDID, fieldType),
399 .field_name = "fieldType",
400 .item = &ASN1_OBJECT_it,
401 },
402 {
403 .flags = ASN1_TFLG_ADB_OID,
404 .tag = -1,
405 .offset = 0,
406 .field_name = "X9_62_FIELDID",
407 .item = (const ASN1_ITEM *)&X9_62_FIELDID_adb,
408 },
409};
410
411const ASN1_ITEM X9_62_FIELDID_it = {
412 .itype = ASN1_ITYPE_SEQUENCE,
413 .utype = V_ASN1_SEQUENCE,
414 .templates = X9_62_FIELDID_seq_tt,
415 .tcount = sizeof(X9_62_FIELDID_seq_tt) / sizeof(ASN1_TEMPLATE),
416 .funcs = NULL,
417 .size = sizeof(X9_62_FIELDID),
418 .sname = "X9_62_FIELDID",
419};
420
421static const ASN1_TEMPLATE X9_62_CURVE_seq_tt[] = {
422 {
423 .flags = 0,
424 .tag = 0,
425 .offset = offsetof(X9_62_CURVE, a),
426 .field_name = "a",
427 .item = &ASN1_OCTET_STRING_it,
428 },
429 {
430 .flags = 0,
431 .tag = 0,
432 .offset = offsetof(X9_62_CURVE, b),
433 .field_name = "b",
434 .item = &ASN1_OCTET_STRING_it,
435 },
436 {
437 .flags = ASN1_TFLG_OPTIONAL,
438 .tag = 0,
439 .offset = offsetof(X9_62_CURVE, seed),
440 .field_name = "seed",
441 .item = &ASN1_BIT_STRING_it,
442 },
443};
444
445const ASN1_ITEM X9_62_CURVE_it = {
446 .itype = ASN1_ITYPE_SEQUENCE,
447 .utype = V_ASN1_SEQUENCE,
448 .templates = X9_62_CURVE_seq_tt,
449 .tcount = sizeof(X9_62_CURVE_seq_tt) / sizeof(ASN1_TEMPLATE),
450 .funcs = NULL,
451 .size = sizeof(X9_62_CURVE),
452 .sname = "X9_62_CURVE",
453};
454
455static const ASN1_TEMPLATE ECPARAMETERS_seq_tt[] = {
456 {
457 .flags = 0,
458 .tag = 0,
459 .offset = offsetof(ECPARAMETERS, version),
460 .field_name = "version",
461 .item = &LONG_it,
462 },
463 {
464 .flags = 0,
465 .tag = 0,
466 .offset = offsetof(ECPARAMETERS, fieldID),
467 .field_name = "fieldID",
468 .item = &X9_62_FIELDID_it,
469 },
470 {
471 .flags = 0,
472 .tag = 0,
473 .offset = offsetof(ECPARAMETERS, curve),
474 .field_name = "curve",
475 .item = &X9_62_CURVE_it,
476 },
477 {
478 .flags = 0,
479 .tag = 0,
480 .offset = offsetof(ECPARAMETERS, base),
481 .field_name = "base",
482 .item = &ASN1_OCTET_STRING_it,
483 },
484 {
485 .flags = 0,
486 .tag = 0,
487 .offset = offsetof(ECPARAMETERS, order),
488 .field_name = "order",
489 .item = &ASN1_INTEGER_it,
490 },
491 {
492 .flags = ASN1_TFLG_OPTIONAL,
493 .tag = 0,
494 .offset = offsetof(ECPARAMETERS, cofactor),
495 .field_name = "cofactor",
496 .item = &ASN1_INTEGER_it,
497 },
498};
499
500const ASN1_ITEM ECPARAMETERS_it = {
501 .itype = ASN1_ITYPE_SEQUENCE,
502 .utype = V_ASN1_SEQUENCE,
503 .templates = ECPARAMETERS_seq_tt,
504 .tcount = sizeof(ECPARAMETERS_seq_tt) / sizeof(ASN1_TEMPLATE),
505 .funcs = NULL,
506 .size = sizeof(ECPARAMETERS),
507 .sname = "ECPARAMETERS",
508};
509ECPARAMETERS *ECPARAMETERS_new(void);
510void ECPARAMETERS_free(ECPARAMETERS *a);
511
512ECPARAMETERS *
513ECPARAMETERS_new(void)
514{
515 return (ECPARAMETERS*)ASN1_item_new(&ECPARAMETERS_it);
516}
517
518void
519ECPARAMETERS_free(ECPARAMETERS *a)
520{
521 ASN1_item_free((ASN1_VALUE *)a, &ECPARAMETERS_it);
522}
523
524static const ASN1_TEMPLATE ECPKPARAMETERS_ch_tt[] = {
525 {
526 .flags = 0,
527 .tag = 0,
528 .offset = offsetof(ECPKPARAMETERS, value.named_curve),
529 .field_name = "value.named_curve",
530 .item = &ASN1_OBJECT_it,
531 },
532 {
533 .flags = 0,
534 .tag = 0,
535 .offset = offsetof(ECPKPARAMETERS, value.parameters),
536 .field_name = "value.parameters",
537 .item = &ECPARAMETERS_it,
538 },
539 {
540 .flags = 0,
541 .tag = 0,
542 .offset = offsetof(ECPKPARAMETERS, value.implicitlyCA),
543 .field_name = "value.implicitlyCA",
544 .item = &ASN1_NULL_it,
545 },
546};
547
548const ASN1_ITEM ECPKPARAMETERS_it = {
549 .itype = ASN1_ITYPE_CHOICE,
550 .utype = offsetof(ECPKPARAMETERS, type),
551 .templates = ECPKPARAMETERS_ch_tt,
552 .tcount = sizeof(ECPKPARAMETERS_ch_tt) / sizeof(ASN1_TEMPLATE),
553 .funcs = NULL,
554 .size = sizeof(ECPKPARAMETERS),
555 .sname = "ECPKPARAMETERS",
556};
557
558ECPKPARAMETERS *ECPKPARAMETERS_new(void);
559void ECPKPARAMETERS_free(ECPKPARAMETERS *a);
560ECPKPARAMETERS *d2i_ECPKPARAMETERS(ECPKPARAMETERS **a, const unsigned char **in, long len);
561int i2d_ECPKPARAMETERS(const ECPKPARAMETERS *a, unsigned char **out);
562
563ECPKPARAMETERS *
564d2i_ECPKPARAMETERS(ECPKPARAMETERS **a, const unsigned char **in, long len)
565{
566 return (ECPKPARAMETERS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
567 &ECPKPARAMETERS_it);
568}
569
570int
571i2d_ECPKPARAMETERS(const ECPKPARAMETERS *a, unsigned char **out)
572{
573 return ASN1_item_i2d((ASN1_VALUE *)a, out, &ECPKPARAMETERS_it);
574}
575
576ECPKPARAMETERS *
577ECPKPARAMETERS_new(void)
578{
579 return (ECPKPARAMETERS *)ASN1_item_new(&ECPKPARAMETERS_it);
580}
581
582void
583ECPKPARAMETERS_free(ECPKPARAMETERS *a)
584{
585 ASN1_item_free((ASN1_VALUE *)a, &ECPKPARAMETERS_it);
586}
587
588static const ASN1_TEMPLATE EC_PRIVATEKEY_seq_tt[] = {
589 {
590 .flags = 0,
591 .tag = 0,
592 .offset = offsetof(EC_PRIVATEKEY, version),
593 .field_name = "version",
594 .item = &LONG_it,
595 },
596 {
597 .flags = 0,
598 .tag = 0,
599 .offset = offsetof(EC_PRIVATEKEY, privateKey),
600 .field_name = "privateKey",
601 .item = &ASN1_OCTET_STRING_it,
602 },
603 {
604 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
605 .tag = 0,
606 .offset = offsetof(EC_PRIVATEKEY, parameters),
607 .field_name = "parameters",
608 .item = &ECPKPARAMETERS_it,
609 },
610 {
611 .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL,
612 .tag = 1,
613 .offset = offsetof(EC_PRIVATEKEY, publicKey),
614 .field_name = "publicKey",
615 .item = &ASN1_BIT_STRING_it,
616 },
617};
618
619const ASN1_ITEM EC_PRIVATEKEY_it = {
620 .itype = ASN1_ITYPE_SEQUENCE,
621 .utype = V_ASN1_SEQUENCE,
622 .templates = EC_PRIVATEKEY_seq_tt,
623 .tcount = sizeof(EC_PRIVATEKEY_seq_tt) / sizeof(ASN1_TEMPLATE),
624 .funcs = NULL,
625 .size = sizeof(EC_PRIVATEKEY),
626 .sname = "EC_PRIVATEKEY",
627};
628
629EC_PRIVATEKEY *EC_PRIVATEKEY_new(void);
630void EC_PRIVATEKEY_free(EC_PRIVATEKEY *a);
631EC_PRIVATEKEY *d2i_EC_PRIVATEKEY(EC_PRIVATEKEY **a, const unsigned char **in, long len);
632int i2d_EC_PRIVATEKEY(const EC_PRIVATEKEY *a, unsigned char **out);
633
634EC_PRIVATEKEY *
635d2i_EC_PRIVATEKEY(EC_PRIVATEKEY **a, const unsigned char **in, long len)
636{
637 return (EC_PRIVATEKEY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
638 &EC_PRIVATEKEY_it);
639}
640
641int
642i2d_EC_PRIVATEKEY(const EC_PRIVATEKEY *a, unsigned char **out)
643{
644 return ASN1_item_i2d((ASN1_VALUE *)a, out, &EC_PRIVATEKEY_it);
645}
646
647EC_PRIVATEKEY *
648EC_PRIVATEKEY_new(void)
649{
650 return (EC_PRIVATEKEY *)ASN1_item_new(&EC_PRIVATEKEY_it);
651}
652
653void
654EC_PRIVATEKEY_free(EC_PRIVATEKEY *a)
655{
656 ASN1_item_free((ASN1_VALUE *)a, &EC_PRIVATEKEY_it);
657}
658/* some declarations of internal function */
659
660/* ec_asn1_group2field() sets the values in a X9_62_FIELDID object */
661static int ec_asn1_group2fieldid(const EC_GROUP *, X9_62_FIELDID *);
662/* ec_asn1_group2curve() sets the values in a X9_62_CURVE object */
663static int ec_asn1_group2curve(const EC_GROUP *, X9_62_CURVE *);
664/* ec_asn1_parameters2group() creates a EC_GROUP object from a
665 * ECPARAMETERS object */
666static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *);
667/* ec_asn1_group2parameters() creates a ECPARAMETERS object from a
668 * EC_GROUP object */
669static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *, ECPARAMETERS *);
670/* ec_asn1_pkparameters2group() creates a EC_GROUP object from a
671 * ECPKPARAMETERS object */
672static EC_GROUP *ec_asn1_pkparameters2group(const ECPKPARAMETERS *);
673/* ec_asn1_group2pkparameters() creates a ECPKPARAMETERS object from a
674 * EC_GROUP object */
675static ECPKPARAMETERS *ec_asn1_group2pkparameters(const EC_GROUP *,
676 ECPKPARAMETERS *);
677
678
679/* the function definitions */
680
681static int
682ec_asn1_group2fieldid(const EC_GROUP * group, X9_62_FIELDID * field)
683{
684 int ok = 0, nid;
685 BIGNUM *tmp = NULL;
686
687 if (group == NULL || field == NULL)
688 return 0;
689
690 /* clear the old values (if necessary) */
691 if (field->fieldType != NULL)
692 ASN1_OBJECT_free(field->fieldType);
693 if (field->p.other != NULL)
694 ASN1_TYPE_free(field->p.other);
695
696 nid = EC_METHOD_get_field_type(EC_GROUP_method_of(group));
697 /* set OID for the field */
698 if ((field->fieldType = OBJ_nid2obj(nid)) == NULL) {
699 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_OBJ_LIB);
700 goto err;
701 }
702 if (nid == NID_X9_62_prime_field) {
703 if ((tmp = BN_new()) == NULL) {
704 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
705 goto err;
706 }
707 /* the parameters are specified by the prime number p */
708 if (!EC_GROUP_get_curve_GFp(group, tmp, NULL, NULL, NULL)) {
709 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_EC_LIB);
710 goto err;
711 }
712 /* set the prime number */
713 field->p.prime = BN_to_ASN1_INTEGER(tmp, NULL);
714 if (field->p.prime == NULL) {
715 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_ASN1_LIB);
716 goto err;
717 }
718 } else /* nid == NID_X9_62_characteristic_two_field */
719#ifdef OPENSSL_NO_EC2M
720 {
721 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, EC_R_GF2M_NOT_SUPPORTED);
722 goto err;
723 }
724#else
725 {
726 int field_type;
727 X9_62_CHARACTERISTIC_TWO *char_two;
728
729 field->p.char_two = X9_62_CHARACTERISTIC_TWO_new();
730 char_two = field->p.char_two;
731
732 if (char_two == NULL) {
733 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
734 goto err;
735 }
736 char_two->m = (long) EC_GROUP_get_degree(group);
737
738 field_type = EC_GROUP_get_basis_type(group);
739
740 if (field_type == 0) {
741 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_EC_LIB);
742 goto err;
743 }
744 /* set base type OID */
745 if ((char_two->type = OBJ_nid2obj(field_type)) == NULL) {
746 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_OBJ_LIB);
747 goto err;
748 }
749 if (field_type == NID_X9_62_tpBasis) {
750 unsigned int k;
751
752 if (!EC_GROUP_get_trinomial_basis(group, &k))
753 goto err;
754
755 char_two->p.tpBasis = ASN1_INTEGER_new();
756 if (!char_two->p.tpBasis) {
757 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
758 goto err;
759 }
760 if (!ASN1_INTEGER_set(char_two->p.tpBasis, (long) k)) {
761 ECerr(EC_F_EC_ASN1_GROUP2FIELDID,
762 ERR_R_ASN1_LIB);
763 goto err;
764 }
765 } else if (field_type == NID_X9_62_ppBasis) {
766 unsigned int k1, k2, k3;
767
768 if (!EC_GROUP_get_pentanomial_basis(group, &k1, &k2, &k3))
769 goto err;
770
771 char_two->p.ppBasis = X9_62_PENTANOMIAL_new();
772 if (!char_two->p.ppBasis) {
773 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
774 goto err;
775 }
776 /* set k? values */
777 char_two->p.ppBasis->k1 = (long) k1;
778 char_two->p.ppBasis->k2 = (long) k2;
779 char_two->p.ppBasis->k3 = (long) k3;
780 } else { /* field_type == NID_X9_62_onBasis */
781 /* for ONB the parameters are (asn1) NULL */
782 char_two->p.onBasis = ASN1_NULL_new();
783 if (!char_two->p.onBasis) {
784 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
785 goto err;
786 }
787 }
788 }
789#endif
790
791 ok = 1;
792
793err:
794 BN_free(tmp);
795 return (ok);
796}
797
798static int
799ec_asn1_group2curve(const EC_GROUP * group, X9_62_CURVE * curve)
800{
801 int ok = 0, nid;
802 BIGNUM *tmp_1 = NULL, *tmp_2 = NULL;
803 unsigned char *buffer_1 = NULL, *buffer_2 = NULL, *a_buf = NULL,
804 *b_buf = NULL;
805 size_t len_1, len_2;
806 unsigned char char_zero = 0;
807
808 if (!group || !curve || !curve->a || !curve->b)
809 return 0;
810
811 if ((tmp_1 = BN_new()) == NULL || (tmp_2 = BN_new()) == NULL) {
812 ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_MALLOC_FAILURE);
813 goto err;
814 }
815 nid = EC_METHOD_get_field_type(EC_GROUP_method_of(group));
816
817 /* get a and b */
818 if (nid == NID_X9_62_prime_field) {
819 if (!EC_GROUP_get_curve_GFp(group, NULL, tmp_1, tmp_2, NULL)) {
820 ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_EC_LIB);
821 goto err;
822 }
823 }
824#ifndef OPENSSL_NO_EC2M
825 else { /* nid == NID_X9_62_characteristic_two_field */
826 if (!EC_GROUP_get_curve_GF2m(group, NULL, tmp_1, tmp_2, NULL)) {
827 ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_EC_LIB);
828 goto err;
829 }
830 }
831#endif
832 len_1 = (size_t) BN_num_bytes(tmp_1);
833 len_2 = (size_t) BN_num_bytes(tmp_2);
834
835 if (len_1 == 0) {
836 /* len_1 == 0 => a == 0 */
837 a_buf = &char_zero;
838 len_1 = 1;
839 } else {
840 if ((buffer_1 = malloc(len_1)) == NULL) {
841 ECerr(EC_F_EC_ASN1_GROUP2CURVE,
842 ERR_R_MALLOC_FAILURE);
843 goto err;
844 }
845 if ((len_1 = BN_bn2bin(tmp_1, buffer_1)) == 0) {
846 ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_BN_LIB);
847 goto err;
848 }
849 a_buf = buffer_1;
850 }
851
852 if (len_2 == 0) {
853 /* len_2 == 0 => b == 0 */
854 b_buf = &char_zero;
855 len_2 = 1;
856 } else {
857 if ((buffer_2 = malloc(len_2)) == NULL) {
858 ECerr(EC_F_EC_ASN1_GROUP2CURVE,
859 ERR_R_MALLOC_FAILURE);
860 goto err;
861 }
862 if ((len_2 = BN_bn2bin(tmp_2, buffer_2)) == 0) {
863 ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_BN_LIB);
864 goto err;
865 }
866 b_buf = buffer_2;
867 }
868
869 /* set a and b */
870 if (!ASN1_STRING_set(curve->a, a_buf, len_1) ||
871 !ASN1_STRING_set(curve->b, b_buf, len_2)) {
872 ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_ASN1_LIB);
873 goto err;
874 }
875 /* set the seed (optional) */
876 if (group->seed) {
877 if (!curve->seed)
878 if ((curve->seed = ASN1_BIT_STRING_new()) == NULL) {
879 ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_MALLOC_FAILURE);
880 goto err;
881 }
882 curve->seed->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);
883 curve->seed->flags |= ASN1_STRING_FLAG_BITS_LEFT;
884 if (!ASN1_BIT_STRING_set(curve->seed, group->seed,
885 (int) group->seed_len)) {
886 ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_ASN1_LIB);
887 goto err;
888 }
889 } else {
890 if (curve->seed) {
891 ASN1_BIT_STRING_free(curve->seed);
892 curve->seed = NULL;
893 }
894 }
895
896 ok = 1;
897
898err:
899 free(buffer_1);
900 free(buffer_2);
901 BN_free(tmp_1);
902 BN_free(tmp_2);
903 return (ok);
904}
905
906static ECPARAMETERS *
907ec_asn1_group2parameters(const EC_GROUP * group, ECPARAMETERS * param)
908{
909 int ok = 0;
910 size_t len = 0;
911 ECPARAMETERS *ret = NULL;
912 BIGNUM *tmp = NULL;
913 unsigned char *buffer = NULL;
914 const EC_POINT *point = NULL;
915 point_conversion_form_t form;
916
917 if ((tmp = BN_new()) == NULL) {
918 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_MALLOC_FAILURE);
919 goto err;
920 }
921 if (param == NULL) {
922 if ((ret = ECPARAMETERS_new()) == NULL) {
923 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS,
924 ERR_R_MALLOC_FAILURE);
925 goto err;
926 }
927 } else
928 ret = param;
929
930 /* set the version (always one) */
931 ret->version = (long) 0x1;
932
933 /* set the fieldID */
934 if (!ec_asn1_group2fieldid(group, ret->fieldID)) {
935 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
936 goto err;
937 }
938 /* set the curve */
939 if (!ec_asn1_group2curve(group, ret->curve)) {
940 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
941 goto err;
942 }
943 /* set the base point */
944 if ((point = EC_GROUP_get0_generator(group)) == NULL) {
945 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, EC_R_UNDEFINED_GENERATOR);
946 goto err;
947 }
948 form = EC_GROUP_get_point_conversion_form(group);
949
950 len = EC_POINT_point2oct(group, point, form, NULL, len, NULL);
951 if (len == 0) {
952 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
953 goto err;
954 }
955 if ((buffer = malloc(len)) == NULL) {
956 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_MALLOC_FAILURE);
957 goto err;
958 }
959 if (!EC_POINT_point2oct(group, point, form, buffer, len, NULL)) {
960 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
961 goto err;
962 }
963 if (ret->base == NULL && (ret->base = ASN1_OCTET_STRING_new()) == NULL) {
964 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_MALLOC_FAILURE);
965 goto err;
966 }
967 if (!ASN1_OCTET_STRING_set(ret->base, buffer, len)) {
968 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB);
969 goto err;
970 }
971 /* set the order */
972 if (!EC_GROUP_get_order(group, tmp, NULL)) {
973 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
974 goto err;
975 }
976 ret->order = BN_to_ASN1_INTEGER(tmp, ret->order);
977 if (ret->order == NULL) {
978 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB);
979 goto err;
980 }
981 /* set the cofactor (optional) */
982 if (EC_GROUP_get_cofactor(group, tmp, NULL)) {
983 ret->cofactor = BN_to_ASN1_INTEGER(tmp, ret->cofactor);
984 if (ret->cofactor == NULL) {
985 ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB);
986 goto err;
987 }
988 }
989 ok = 1;
990
991err: if (!ok) {
992 if (ret && !param)
993 ECPARAMETERS_free(ret);
994 ret = NULL;
995 }
996 BN_free(tmp);
997 free(buffer);
998 return (ret);
999}
1000
1001ECPKPARAMETERS *
1002ec_asn1_group2pkparameters(const EC_GROUP * group, ECPKPARAMETERS * params)
1003{
1004 int ok = 1, tmp;
1005 ECPKPARAMETERS *ret = params;
1006
1007 if (ret == NULL) {
1008 if ((ret = ECPKPARAMETERS_new()) == NULL) {
1009 ECerr(EC_F_EC_ASN1_GROUP2PKPARAMETERS,
1010 ERR_R_MALLOC_FAILURE);
1011 return NULL;
1012 }
1013 } else {
1014 if (ret->type == 0 && ret->value.named_curve)
1015 ASN1_OBJECT_free(ret->value.named_curve);
1016 else if (ret->type == 1 && ret->value.parameters)
1017 ECPARAMETERS_free(ret->value.parameters);
1018 }
1019
1020 if (EC_GROUP_get_asn1_flag(group)) {
1021 /*
1022 * use the asn1 OID to describe the elliptic curve
1023 * parameters
1024 */
1025 tmp = EC_GROUP_get_curve_name(group);
1026 if (tmp) {
1027 ret->type = 0;
1028 if ((ret->value.named_curve = OBJ_nid2obj(tmp)) == NULL)
1029 ok = 0;
1030 } else
1031 /* we don't kmow the nid => ERROR */
1032 ok = 0;
1033 } else {
1034 /* use the ECPARAMETERS structure */
1035 ret->type = 1;
1036 if ((ret->value.parameters = ec_asn1_group2parameters(
1037 group, NULL)) == NULL)
1038 ok = 0;
1039 }
1040
1041 if (!ok) {
1042 ECPKPARAMETERS_free(ret);
1043 return NULL;
1044 }
1045 return ret;
1046}
1047
1048static EC_GROUP *
1049ec_asn1_parameters2group(const ECPARAMETERS * params)
1050{
1051 int ok = 0, tmp;
1052 EC_GROUP *ret = NULL;
1053 BIGNUM *p = NULL, *a = NULL, *b = NULL;
1054 EC_POINT *point = NULL;
1055 long field_bits;
1056
1057 if (!params->fieldID || !params->fieldID->fieldType ||
1058 !params->fieldID->p.ptr) {
1059 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
1060 goto err;
1061 }
1062 /* now extract the curve parameters a and b */
1063 if (!params->curve || !params->curve->a ||
1064 !params->curve->a->data || !params->curve->b ||
1065 !params->curve->b->data) {
1066 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
1067 goto err;
1068 }
1069 a = BN_bin2bn(params->curve->a->data, params->curve->a->length, NULL);
1070 if (a == NULL) {
1071 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_BN_LIB);
1072 goto err;
1073 }
1074 b = BN_bin2bn(params->curve->b->data, params->curve->b->length, NULL);
1075 if (b == NULL) {
1076 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_BN_LIB);
1077 goto err;
1078 }
1079 /* get the field parameters */
1080 tmp = OBJ_obj2nid(params->fieldID->fieldType);
1081 if (tmp == NID_X9_62_characteristic_two_field)
1082#ifdef OPENSSL_NO_EC2M
1083 {
1084 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_GF2M_NOT_SUPPORTED);
1085 goto err;
1086 }
1087#else
1088 {
1089 X9_62_CHARACTERISTIC_TWO *char_two;
1090
1091 char_two = params->fieldID->p.char_two;
1092
1093 field_bits = char_two->m;
1094 if (field_bits > OPENSSL_ECC_MAX_FIELD_BITS) {
1095 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_FIELD_TOO_LARGE);
1096 goto err;
1097 }
1098 if ((p = BN_new()) == NULL) {
1099 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_MALLOC_FAILURE);
1100 goto err;
1101 }
1102 /* get the base type */
1103 tmp = OBJ_obj2nid(char_two->type);
1104
1105 if (tmp == NID_X9_62_tpBasis) {
1106 long tmp_long;
1107
1108 if (!char_two->p.tpBasis) {
1109 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
1110 goto err;
1111 }
1112 tmp_long = ASN1_INTEGER_get(char_two->p.tpBasis);
1113
1114 if (!(char_two->m > tmp_long && tmp_long > 0)) {
1115 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_TRINOMIAL_BASIS);
1116 goto err;
1117 }
1118 /* create the polynomial */
1119 if (!BN_set_bit(p, (int) char_two->m))
1120 goto err;
1121 if (!BN_set_bit(p, (int) tmp_long))
1122 goto err;
1123 if (!BN_set_bit(p, 0))
1124 goto err;
1125 } else if (tmp == NID_X9_62_ppBasis) {
1126 X9_62_PENTANOMIAL *penta;
1127
1128 penta = char_two->p.ppBasis;
1129 if (!penta) {
1130 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
1131 goto err;
1132 }
1133 if (!(char_two->m > penta->k3 && penta->k3 > penta->k2 && penta->k2 > penta->k1 && penta->k1 > 0)) {
1134 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_PENTANOMIAL_BASIS);
1135 goto err;
1136 }
1137 /* create the polynomial */
1138 if (!BN_set_bit(p, (int) char_two->m))
1139 goto err;
1140 if (!BN_set_bit(p, (int) penta->k1))
1141 goto err;
1142 if (!BN_set_bit(p, (int) penta->k2))
1143 goto err;
1144 if (!BN_set_bit(p, (int) penta->k3))
1145 goto err;
1146 if (!BN_set_bit(p, 0))
1147 goto err;
1148 } else if (tmp == NID_X9_62_onBasis) {
1149 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_NOT_IMPLEMENTED);
1150 goto err;
1151 } else { /* error */
1152 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
1153 goto err;
1154 }
1155
1156 /* create the EC_GROUP structure */
1157 ret = EC_GROUP_new_curve_GF2m(p, a, b, NULL);
1158 }
1159#endif
1160 else if (tmp == NID_X9_62_prime_field) {
1161 /* we have a curve over a prime field */
1162 /* extract the prime number */
1163 if (!params->fieldID->p.prime) {
1164 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
1165 goto err;
1166 }
1167 p = ASN1_INTEGER_to_BN(params->fieldID->p.prime, NULL);
1168 if (p == NULL) {
1169 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
1170 goto err;
1171 }
1172 if (BN_is_negative(p) || BN_is_zero(p)) {
1173 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_FIELD);
1174 goto err;
1175 }
1176 field_bits = BN_num_bits(p);
1177 if (field_bits > OPENSSL_ECC_MAX_FIELD_BITS) {
1178 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_FIELD_TOO_LARGE);
1179 goto err;
1180 }
1181 /* create the EC_GROUP structure */
1182 ret = EC_GROUP_new_curve_GFp(p, a, b, NULL);
1183 } else {
1184 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_FIELD);
1185 goto err;
1186 }
1187
1188 if (ret == NULL) {
1189 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB);
1190 goto err;
1191 }
1192 /* extract seed (optional) */
1193 if (params->curve->seed != NULL) {
1194 free(ret->seed);
1195 if (!(ret->seed = malloc(params->curve->seed->length))) {
1196 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP,
1197 ERR_R_MALLOC_FAILURE);
1198 goto err;
1199 }
1200 memcpy(ret->seed, params->curve->seed->data,
1201 params->curve->seed->length);
1202 ret->seed_len = params->curve->seed->length;
1203 }
1204 if (!params->order || !params->base || !params->base->data) {
1205 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
1206 goto err;
1207 }
1208 if ((point = EC_POINT_new(ret)) == NULL)
1209 goto err;
1210
1211 /* set the point conversion form */
1212 EC_GROUP_set_point_conversion_form(ret, (point_conversion_form_t)
1213 (params->base->data[0] & ~0x01));
1214
1215 /* extract the ec point */
1216 if (!EC_POINT_oct2point(ret, point, params->base->data,
1217 params->base->length, NULL)) {
1218 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB);
1219 goto err;
1220 }
1221 /* extract the order */
1222 if ((a = ASN1_INTEGER_to_BN(params->order, a)) == NULL) {
1223 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
1224 goto err;
1225 }
1226 if (BN_is_negative(a) || BN_is_zero(a)) {
1227 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_GROUP_ORDER);
1228 goto err;
1229 }
1230 if (BN_num_bits(a) > (int) field_bits + 1) { /* Hasse bound */
1231 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_GROUP_ORDER);
1232 goto err;
1233 }
1234 /* extract the cofactor (optional) */
1235 if (params->cofactor == NULL) {
1236 BN_free(b);
1237 b = NULL;
1238 } else if ((b = ASN1_INTEGER_to_BN(params->cofactor, b)) == NULL) {
1239 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
1240 goto err;
1241 }
1242 /* set the generator, order and cofactor (if present) */
1243 if (!EC_GROUP_set_generator(ret, point, a, b)) {
1244 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB);
1245 goto err;
1246 }
1247 ok = 1;
1248
1249err: if (!ok) {
1250 EC_GROUP_clear_free(ret);
1251 ret = NULL;
1252 }
1253 BN_free(p);
1254 BN_free(a);
1255 BN_free(b);
1256 EC_POINT_free(point);
1257 return (ret);
1258}
1259
1260EC_GROUP *
1261ec_asn1_pkparameters2group(const ECPKPARAMETERS * params)
1262{
1263 EC_GROUP *ret = NULL;
1264 int tmp = 0;
1265
1266 if (params == NULL) {
1267 ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP,
1268 EC_R_MISSING_PARAMETERS);
1269 return NULL;
1270 }
1271 if (params->type == 0) {/* the curve is given by an OID */
1272 tmp = OBJ_obj2nid(params->value.named_curve);
1273 if ((ret = EC_GROUP_new_by_curve_name(tmp)) == NULL) {
1274 ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP,
1275 EC_R_EC_GROUP_NEW_BY_NAME_FAILURE);
1276 return NULL;
1277 }
1278 EC_GROUP_set_asn1_flag(ret, OPENSSL_EC_NAMED_CURVE);
1279 } else if (params->type == 1) { /* the parameters are given by a
1280 * ECPARAMETERS structure */
1281 ret = ec_asn1_parameters2group(params->value.parameters);
1282 if (!ret) {
1283 ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP, ERR_R_EC_LIB);
1284 return NULL;
1285 }
1286 EC_GROUP_set_asn1_flag(ret, 0x0);
1287 } else if (params->type == 2) { /* implicitlyCA */
1288 return NULL;
1289 } else {
1290 ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP, EC_R_ASN1_ERROR);
1291 return NULL;
1292 }
1293
1294 return ret;
1295}
1296
1297/* EC_GROUP <-> DER encoding of ECPKPARAMETERS */
1298
1299EC_GROUP *
1300d2i_ECPKParameters(EC_GROUP ** a, const unsigned char **in, long len)
1301{
1302 EC_GROUP *group = NULL;
1303 ECPKPARAMETERS *params = NULL;
1304
1305 if ((params = d2i_ECPKPARAMETERS(NULL, in, len)) == NULL) {
1306 ECerr(EC_F_D2I_ECPKPARAMETERS, EC_R_D2I_ECPKPARAMETERS_FAILURE);
1307 goto err;
1308 }
1309 if ((group = ec_asn1_pkparameters2group(params)) == NULL) {
1310 ECerr(EC_F_D2I_ECPKPARAMETERS, EC_R_PKPARAMETERS2GROUP_FAILURE);
1311 goto err;
1312 }
1313
1314 if (a != NULL) {
1315 EC_GROUP_clear_free(*a);
1316 *a = group;
1317 }
1318
1319err:
1320 ECPKPARAMETERS_free(params);
1321 return (group);
1322}
1323
1324int
1325i2d_ECPKParameters(const EC_GROUP * a, unsigned char **out)
1326{
1327 int ret = 0;
1328 ECPKPARAMETERS *tmp = ec_asn1_group2pkparameters(a, NULL);
1329 if (tmp == NULL) {
1330 ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_GROUP2PKPARAMETERS_FAILURE);
1331 return 0;
1332 }
1333 if ((ret = i2d_ECPKPARAMETERS(tmp, out)) == 0) {
1334 ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_I2D_ECPKPARAMETERS_FAILURE);
1335 ECPKPARAMETERS_free(tmp);
1336 return 0;
1337 }
1338 ECPKPARAMETERS_free(tmp);
1339 return (ret);
1340}
1341
1342/* some EC_KEY functions */
1343
1344EC_KEY *
1345d2i_ECPrivateKey(EC_KEY ** a, const unsigned char **in, long len)
1346{
1347 EC_KEY *ret = NULL;
1348 EC_PRIVATEKEY *priv_key = NULL;
1349
1350 if ((priv_key = EC_PRIVATEKEY_new()) == NULL) {
1351 ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
1352 return NULL;
1353 }
1354 if ((priv_key = d2i_EC_PRIVATEKEY(&priv_key, in, len)) == NULL) {
1355 ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
1356 EC_PRIVATEKEY_free(priv_key);
1357 return NULL;
1358 }
1359 if (a == NULL || *a == NULL) {
1360 if ((ret = EC_KEY_new()) == NULL) {
1361 ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
1362 goto err;
1363 }
1364 } else
1365 ret = *a;
1366
1367 if (priv_key->parameters) {
1368 EC_GROUP_clear_free(ret->group);
1369 ret->group = ec_asn1_pkparameters2group(priv_key->parameters);
1370 }
1371 if (ret->group == NULL) {
1372 ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
1373 goto err;
1374 }
1375 ret->version = priv_key->version;
1376
1377 if (priv_key->privateKey) {
1378 ret->priv_key = BN_bin2bn(
1379 ASN1_STRING_data(priv_key->privateKey),
1380 ASN1_STRING_length(priv_key->privateKey),
1381 ret->priv_key);
1382 if (ret->priv_key == NULL) {
1383 ECerr(EC_F_D2I_ECPRIVATEKEY,
1384 ERR_R_BN_LIB);
1385 goto err;
1386 }
1387 } else {
1388 ECerr(EC_F_D2I_ECPRIVATEKEY,
1389 EC_R_MISSING_PRIVATE_KEY);
1390 goto err;
1391 }
1392
1393 if (priv_key->publicKey) {
1394 const unsigned char *pub_oct;
1395 size_t pub_oct_len;
1396
1397 EC_POINT_clear_free(ret->pub_key);
1398 ret->pub_key = EC_POINT_new(ret->group);
1399 if (ret->pub_key == NULL) {
1400 ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
1401 goto err;
1402 }
1403 pub_oct = ASN1_STRING_data(priv_key->publicKey);
1404 pub_oct_len = ASN1_STRING_length(priv_key->publicKey);
1405 /* save the point conversion form */
1406 ret->conv_form = (point_conversion_form_t) (pub_oct[0] & ~0x01);
1407 if (!EC_POINT_oct2point(ret->group, ret->pub_key,
1408 pub_oct, pub_oct_len, NULL)) {
1409 ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
1410 goto err;
1411 }
1412 }
1413
1414 EC_PRIVATEKEY_free(priv_key);
1415 if (a != NULL)
1416 *a = ret;
1417 return (ret);
1418
1419err:
1420 if (a == NULL || *a != ret)
1421 EC_KEY_free(ret);
1422 if (priv_key)
1423 EC_PRIVATEKEY_free(priv_key);
1424
1425 return (NULL);
1426}
1427
1428int
1429i2d_ECPrivateKey(EC_KEY * a, unsigned char **out)
1430{
1431 int ret = 0, ok = 0;
1432 unsigned char *buffer = NULL;
1433 size_t buf_len = 0, tmp_len;
1434 EC_PRIVATEKEY *priv_key = NULL;
1435
1436 if (a == NULL || a->group == NULL || a->priv_key == NULL) {
1437 ECerr(EC_F_I2D_ECPRIVATEKEY,
1438 ERR_R_PASSED_NULL_PARAMETER);
1439 goto err;
1440 }
1441 if ((priv_key = EC_PRIVATEKEY_new()) == NULL) {
1442 ECerr(EC_F_I2D_ECPRIVATEKEY,
1443 ERR_R_MALLOC_FAILURE);
1444 goto err;
1445 }
1446 priv_key->version = a->version;
1447
1448 buf_len = (size_t) BN_num_bytes(a->priv_key);
1449 buffer = malloc(buf_len);
1450 if (buffer == NULL) {
1451 ECerr(EC_F_I2D_ECPRIVATEKEY,
1452 ERR_R_MALLOC_FAILURE);
1453 goto err;
1454 }
1455 if (!BN_bn2bin(a->priv_key, buffer)) {
1456 ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_BN_LIB);
1457 goto err;
1458 }
1459 if (!ASN1_STRING_set(priv_key->privateKey, buffer, buf_len)) {
1460 ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_ASN1_LIB);
1461 goto err;
1462 }
1463 if (!(a->enc_flag & EC_PKEY_NO_PARAMETERS)) {
1464 if ((priv_key->parameters = ec_asn1_group2pkparameters(
1465 a->group, priv_key->parameters)) == NULL) {
1466 ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
1467 goto err;
1468 }
1469 }
1470 if (!(a->enc_flag & EC_PKEY_NO_PUBKEY) && a->pub_key != NULL) {
1471 priv_key->publicKey = ASN1_BIT_STRING_new();
1472 if (priv_key->publicKey == NULL) {
1473 ECerr(EC_F_I2D_ECPRIVATEKEY,
1474 ERR_R_MALLOC_FAILURE);
1475 goto err;
1476 }
1477 tmp_len = EC_POINT_point2oct(a->group, a->pub_key,
1478 a->conv_form, NULL, 0, NULL);
1479
1480 if (tmp_len > buf_len) {
1481 unsigned char *tmp_buffer = realloc(buffer, tmp_len);
1482 if (!tmp_buffer) {
1483 ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
1484 goto err;
1485 }
1486 buffer = tmp_buffer;
1487 buf_len = tmp_len;
1488 }
1489 if (!EC_POINT_point2oct(a->group, a->pub_key,
1490 a->conv_form, buffer, buf_len, NULL)) {
1491 ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
1492 goto err;
1493 }
1494 priv_key->publicKey->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);
1495 priv_key->publicKey->flags |= ASN1_STRING_FLAG_BITS_LEFT;
1496 if (!ASN1_STRING_set(priv_key->publicKey, buffer,
1497 buf_len)) {
1498 ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_ASN1_LIB);
1499 goto err;
1500 }
1501 }
1502 if ((ret = i2d_EC_PRIVATEKEY(priv_key, out)) == 0) {
1503 ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
1504 goto err;
1505 }
1506 ok = 1;
1507err:
1508 free(buffer);
1509 if (priv_key)
1510 EC_PRIVATEKEY_free(priv_key);
1511 return (ok ? ret : 0);
1512}
1513
1514int
1515i2d_ECParameters(EC_KEY * a, unsigned char **out)
1516{
1517 if (a == NULL) {
1518 ECerr(EC_F_I2D_ECPARAMETERS, ERR_R_PASSED_NULL_PARAMETER);
1519 return 0;
1520 }
1521 return i2d_ECPKParameters(a->group, out);
1522}
1523
1524EC_KEY *
1525d2i_ECParameters(EC_KEY ** a, const unsigned char **in, long len)
1526{
1527 EC_KEY *ret;
1528
1529 if (in == NULL || *in == NULL) {
1530 ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_PASSED_NULL_PARAMETER);
1531 return NULL;
1532 }
1533 if (a == NULL || *a == NULL) {
1534 if ((ret = EC_KEY_new()) == NULL) {
1535 ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_MALLOC_FAILURE);
1536 return NULL;
1537 }
1538 } else
1539 ret = *a;
1540
1541 if (!d2i_ECPKParameters(&ret->group, in, len)) {
1542 ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_EC_LIB);
1543 if (a == NULL || *a != ret)
1544 EC_KEY_free(ret);
1545 return NULL;
1546 }
1547
1548 if (a != NULL)
1549 *a = ret;
1550 return ret;
1551}
1552
1553EC_KEY *
1554o2i_ECPublicKey(EC_KEY ** a, const unsigned char **in, long len)
1555{
1556 EC_KEY *ret = NULL;
1557
1558 if (a == NULL || (*a) == NULL || (*a)->group == NULL) {
1559 /*
1560 * sorry, but a EC_GROUP-structur is necessary to set the
1561 * public key
1562 */
1563 ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_PASSED_NULL_PARAMETER);
1564 return 0;
1565 }
1566 ret = *a;
1567 if (ret->pub_key == NULL &&
1568 (ret->pub_key = EC_POINT_new(ret->group)) == NULL) {
1569 ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_MALLOC_FAILURE);
1570 return 0;
1571 }
1572 if (!EC_POINT_oct2point(ret->group, ret->pub_key, *in, len, NULL)) {
1573 ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_EC_LIB);
1574 return 0;
1575 }
1576 /* save the point conversion form */
1577 ret->conv_form = (point_conversion_form_t) (*in[0] & ~0x01);
1578 *in += len;
1579 return ret;
1580}
1581
1582int
1583i2o_ECPublicKey(EC_KEY * a, unsigned char **out)
1584{
1585 size_t buf_len = 0;
1586 int new_buffer = 0;
1587
1588 if (a == NULL) {
1589 ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_PASSED_NULL_PARAMETER);
1590 return 0;
1591 }
1592 buf_len = EC_POINT_point2oct(a->group, a->pub_key,
1593 a->conv_form, NULL, 0, NULL);
1594
1595 if (out == NULL || buf_len == 0)
1596 /* out == NULL => just return the length of the octet string */
1597 return buf_len;
1598
1599 if (*out == NULL) {
1600 if ((*out = malloc(buf_len)) == NULL) {
1601 ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_MALLOC_FAILURE);
1602 return 0;
1603 }
1604 new_buffer = 1;
1605 }
1606 if (!EC_POINT_point2oct(a->group, a->pub_key, a->conv_form,
1607 *out, buf_len, NULL)) {
1608 ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_EC_LIB);
1609 if (new_buffer) {
1610 free(*out);
1611 *out = NULL;
1612 }
1613 return 0;
1614 }
1615 if (!new_buffer)
1616 *out += buf_len;
1617 return buf_len;
1618}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-05-07 22:14:59 +0000