0682bc3d1d59b5a347c3d02249a7fba2b76afc4f
[openssl.git] / crypto / ec / ec_ameth.c
1 /*
2  * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/x509.h>
13 #include <openssl/ec.h>
14 #include <openssl/bn.h>
15 #include <openssl/cms.h>
16 #include <openssl/asn1t.h>
17 #include "internal/asn1_int.h"
18 #include "internal/evp_int.h"
19 #include "ec_lcl.h"
20
21 #ifndef OPENSSL_NO_CMS
22 static int ecdh_cms_decrypt(CMS_RecipientInfo *ri);
23 static int ecdh_cms_encrypt(CMS_RecipientInfo *ri);
24 #endif
25
26 static int eckey_param2type(int *pptype, void **ppval, EC_KEY *ec_key)
27 {
28     const EC_GROUP *group;
29     int nid;
30     if (ec_key == NULL || (group = EC_KEY_get0_group(ec_key)) == NULL) {
31         ECerr(EC_F_ECKEY_PARAM2TYPE, EC_R_MISSING_PARAMETERS);
32         return 0;
33     }
34     if (EC_GROUP_get_asn1_flag(group)
35         && (nid = EC_GROUP_get_curve_name(group)))
36         /* we have a 'named curve' => just set the OID */
37     {
38         *ppval = OBJ_nid2obj(nid);
39         *pptype = V_ASN1_OBJECT;
40     } else {                    /* explicit parameters */
41
42         ASN1_STRING *pstr = NULL;
43         pstr = ASN1_STRING_new();
44         if (pstr == NULL)
45             return 0;
46         pstr->length = i2d_ECParameters(ec_key, &pstr->data);
47         if (pstr->length <= 0) {
48             ASN1_STRING_free(pstr);
49             ECerr(EC_F_ECKEY_PARAM2TYPE, ERR_R_EC_LIB);
50             return 0;
51         }
52         *ppval = pstr;
53         *pptype = V_ASN1_SEQUENCE;
54     }
55     return 1;
56 }
57
58 static int eckey_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
59 {
60     EC_KEY *ec_key = pkey->pkey.ec;
61     void *pval = NULL;
62     int ptype;
63     unsigned char *penc = NULL, *p;
64     int penclen;
65
66     if (!eckey_param2type(&ptype, &pval, ec_key)) {
67         ECerr(EC_F_ECKEY_PUB_ENCODE, ERR_R_EC_LIB);
68         return 0;
69     }
70     penclen = i2o_ECPublicKey(ec_key, NULL);
71     if (penclen <= 0)
72         goto err;
73     penc = OPENSSL_malloc(penclen);
74     if (penc == NULL)
75         goto err;
76     p = penc;
77     penclen = i2o_ECPublicKey(ec_key, &p);
78     if (penclen <= 0)
79         goto err;
80     if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(EVP_PKEY_EC),
81                                ptype, pval, penc, penclen))
82         return 1;
83  err:
84     if (ptype == V_ASN1_OBJECT)
85         ASN1_OBJECT_free(pval);
86     else
87         ASN1_STRING_free(pval);
88     OPENSSL_free(penc);
89     return 0;
90 }
91
92 static EC_KEY *eckey_type2param(int ptype, const void *pval)
93 {
94     EC_KEY *eckey = NULL;
95     if (ptype == V_ASN1_SEQUENCE) {
96         const ASN1_STRING *pstr = pval;
97         const unsigned char *pm = NULL;
98         int pmlen;
99         pm = pstr->data;
100         pmlen = pstr->length;
101         if ((eckey = d2i_ECParameters(NULL, &pm, pmlen)) == NULL) {
102             ECerr(EC_F_ECKEY_TYPE2PARAM, EC_R_DECODE_ERROR);
103             goto ecerr;
104         }
105     } else if (ptype == V_ASN1_OBJECT) {
106         const ASN1_OBJECT *poid = pval;
107         EC_GROUP *group;
108
109         /*
110          * type == V_ASN1_OBJECT => the parameters are given by an asn1 OID
111          */
112         if ((eckey = EC_KEY_new()) == NULL) {
113             ECerr(EC_F_ECKEY_TYPE2PARAM, ERR_R_MALLOC_FAILURE);
114             goto ecerr;
115         }
116         group = EC_GROUP_new_by_curve_name(OBJ_obj2nid(poid));
117         if (group == NULL)
118             goto ecerr;
119         EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE);
120         if (EC_KEY_set_group(eckey, group) == 0)
121             goto ecerr;
122         EC_GROUP_free(group);
123     } else {
124         ECerr(EC_F_ECKEY_TYPE2PARAM, EC_R_DECODE_ERROR);
125         goto ecerr;
126     }
127
128     return eckey;
129
130  ecerr:
131     EC_KEY_free(eckey);
132     return NULL;
133 }
134
135 static int eckey_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
136 {
137     const unsigned char *p = NULL;
138     const void *pval;
139     int ptype, pklen;
140     EC_KEY *eckey = NULL;
141     X509_ALGOR *palg;
142
143     if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, &palg, pubkey))
144         return 0;
145     X509_ALGOR_get0(NULL, &ptype, &pval, palg);
146
147     eckey = eckey_type2param(ptype, pval);
148
149     if (!eckey) {
150         ECerr(EC_F_ECKEY_PUB_DECODE, ERR_R_EC_LIB);
151         return 0;
152     }
153
154     /* We have parameters now set public key */
155     if (!o2i_ECPublicKey(&eckey, &p, pklen)) {
156         ECerr(EC_F_ECKEY_PUB_DECODE, EC_R_DECODE_ERROR);
157         goto ecerr;
158     }
159
160     EVP_PKEY_assign_EC_KEY(pkey, eckey);
161     return 1;
162
163  ecerr:
164     EC_KEY_free(eckey);
165     return 0;
166 }
167
168 static int eckey_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
169 {
170     int r;
171     const EC_GROUP *group = EC_KEY_get0_group(b->pkey.ec);
172     const EC_POINT *pa = EC_KEY_get0_public_key(a->pkey.ec),
173         *pb = EC_KEY_get0_public_key(b->pkey.ec);
174     if (group == NULL || pa == NULL || pb == NULL)
175         return -2;
176     r = EC_POINT_cmp(group, pa, pb, NULL);
177     if (r == 0)
178         return 1;
179     if (r == 1)
180         return 0;
181     return -2;
182 }
183
184 static int eckey_priv_decode(EVP_PKEY *pkey, const PKCS8_PRIV_KEY_INFO *p8)
185 {
186     const unsigned char *p = NULL;
187     const void *pval;
188     int ptype, pklen;
189     EC_KEY *eckey = NULL;
190     const X509_ALGOR *palg;
191
192     if (!PKCS8_pkey_get0(NULL, &p, &pklen, &palg, p8))
193         return 0;
194     X509_ALGOR_get0(NULL, &ptype, &pval, palg);
195
196     eckey = eckey_type2param(ptype, pval);
197
198     if (!eckey)
199         goto ecliberr;
200
201     /* We have parameters now set private key */
202     if (!d2i_ECPrivateKey(&eckey, &p, pklen)) {
203         ECerr(EC_F_ECKEY_PRIV_DECODE, EC_R_DECODE_ERROR);
204         goto ecerr;
205     }
206
207     EVP_PKEY_assign_EC_KEY(pkey, eckey);
208     return 1;
209
210  ecliberr:
211     ECerr(EC_F_ECKEY_PRIV_DECODE, ERR_R_EC_LIB);
212  ecerr:
213     EC_KEY_free(eckey);
214     return 0;
215 }
216
217 static int eckey_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
218 {
219     EC_KEY ec_key = *(pkey->pkey.ec);
220     unsigned char *ep, *p;
221     int eplen, ptype;
222     void *pval;
223     unsigned int old_flags;
224
225     if (!eckey_param2type(&ptype, &pval, &ec_key)) {
226         ECerr(EC_F_ECKEY_PRIV_ENCODE, EC_R_DECODE_ERROR);
227         return 0;
228     }
229
230     /* set the private key */
231
232     /*
233      * do not include the parameters in the SEC1 private key see PKCS#11
234      * 12.11
235      */
236     old_flags = EC_KEY_get_enc_flags(&ec_key);
237     EC_KEY_set_enc_flags(&ec_key, old_flags | EC_PKEY_NO_PARAMETERS);
238
239     eplen = i2d_ECPrivateKey(&ec_key, NULL);
240     if (!eplen) {
241         ECerr(EC_F_ECKEY_PRIV_ENCODE, ERR_R_EC_LIB);
242         return 0;
243     }
244     ep = OPENSSL_malloc(eplen);
245     if (ep == NULL) {
246         ECerr(EC_F_ECKEY_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
247         return 0;
248     }
249     p = ep;
250     if (!i2d_ECPrivateKey(&ec_key, &p)) {
251         OPENSSL_free(ep);
252         ECerr(EC_F_ECKEY_PRIV_ENCODE, ERR_R_EC_LIB);
253         return 0;
254     }
255
256     if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(NID_X9_62_id_ecPublicKey), 0,
257                          ptype, pval, ep, eplen)) {
258         OPENSSL_free(ep);
259         return 0;
260     }
261
262     return 1;
263 }
264
265 static int int_ec_size(const EVP_PKEY *pkey)
266 {
267     return ECDSA_size(pkey->pkey.ec);
268 }
269
270 static int ec_bits(const EVP_PKEY *pkey)
271 {
272     return EC_GROUP_order_bits(EC_KEY_get0_group(pkey->pkey.ec));
273 }
274
275 static int ec_security_bits(const EVP_PKEY *pkey)
276 {
277     int ecbits = ec_bits(pkey);
278     if (ecbits >= 512)
279         return 256;
280     if (ecbits >= 384)
281         return 192;
282     if (ecbits >= 256)
283         return 128;
284     if (ecbits >= 224)
285         return 112;
286     if (ecbits >= 160)
287         return 80;
288     return ecbits / 2;
289 }
290
291 static int ec_missing_parameters(const EVP_PKEY *pkey)
292 {
293     if (pkey->pkey.ec == NULL || EC_KEY_get0_group(pkey->pkey.ec) == NULL)
294         return 1;
295     return 0;
296 }
297
298 static int ec_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
299 {
300     EC_GROUP *group = EC_GROUP_dup(EC_KEY_get0_group(from->pkey.ec));
301
302     if (group == NULL)
303         return 0;
304     if (to->pkey.ec == NULL) {
305         to->pkey.ec = EC_KEY_new();
306         if (to->pkey.ec == NULL)
307             goto err;
308     }
309     if (EC_KEY_set_group(to->pkey.ec, group) == 0)
310         goto err;
311     EC_GROUP_free(group);
312     return 1;
313  err:
314     EC_GROUP_free(group);
315     return 0;
316 }
317
318 static int ec_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b)
319 {
320     const EC_GROUP *group_a = EC_KEY_get0_group(a->pkey.ec),
321         *group_b = EC_KEY_get0_group(b->pkey.ec);
322     if (group_a == NULL || group_b == NULL)
323         return -2;
324     if (EC_GROUP_cmp(group_a, group_b, NULL))
325         return 0;
326     else
327         return 1;
328 }
329
330 static void int_ec_free(EVP_PKEY *pkey)
331 {
332     EC_KEY_free(pkey->pkey.ec);
333 }
334
335 typedef enum {
336     EC_KEY_PRINT_PRIVATE,
337     EC_KEY_PRINT_PUBLIC,
338     EC_KEY_PRINT_PARAM
339 } ec_print_t;
340
341 static int do_EC_KEY_print(BIO *bp, const EC_KEY *x, int off, ec_print_t ktype)
342 {
343     const char *ecstr;
344     unsigned char *priv = NULL, *pub = NULL;
345     size_t privlen = 0, publen = 0;
346     int ret = 0;
347     const EC_GROUP *group;
348
349     if (x == NULL || (group = EC_KEY_get0_group(x)) == NULL) {
350         ECerr(EC_F_DO_EC_KEY_PRINT, ERR_R_PASSED_NULL_PARAMETER);
351         return 0;
352     }
353
354     if (ktype != EC_KEY_PRINT_PARAM && EC_KEY_get0_public_key(x) != NULL) {
355         publen = EC_KEY_key2buf(x, EC_KEY_get_conv_form(x), &pub, NULL);
356         if (publen == 0)
357             goto err;
358     }
359
360     if (ktype == EC_KEY_PRINT_PRIVATE && EC_KEY_get0_private_key(x) != NULL) {
361         privlen = EC_KEY_priv2buf(x, &priv);
362         if (privlen == 0)
363             goto err;
364     }
365
366     if (ktype == EC_KEY_PRINT_PRIVATE)
367         ecstr = "Private-Key";
368     else if (ktype == EC_KEY_PRINT_PUBLIC)
369         ecstr = "Public-Key";
370     else
371         ecstr = "ECDSA-Parameters";
372
373     if (!BIO_indent(bp, off, 128))
374         goto err;
375     if (BIO_printf(bp, "%s: (%d bit)\n", ecstr,
376                    EC_GROUP_order_bits(group)) <= 0)
377         goto err;
378
379     if (privlen != 0) {
380         if (BIO_printf(bp, "%*spriv:\n", off, "") <= 0)
381             goto err;
382         if (ASN1_buf_print(bp, priv, privlen, off + 4) == 0)
383             goto err;
384     }
385
386     if (publen != 0) {
387         if (BIO_printf(bp, "%*spub:\n", off, "") <= 0)
388             goto err;
389         if (ASN1_buf_print(bp, pub, publen, off + 4) == 0)
390             goto err;
391     }
392
393     if (!ECPKParameters_print(bp, group, off))
394         goto err;
395     ret = 1;
396  err:
397     if (!ret)
398         ECerr(EC_F_DO_EC_KEY_PRINT, ERR_R_EC_LIB);
399     OPENSSL_clear_free(priv, privlen);
400     OPENSSL_free(pub);
401     return ret;
402 }
403
404 static int eckey_param_decode(EVP_PKEY *pkey,
405                               const unsigned char **pder, int derlen)
406 {
407     EC_KEY *eckey;
408
409     if ((eckey = d2i_ECParameters(NULL, pder, derlen)) == NULL) {
410         ECerr(EC_F_ECKEY_PARAM_DECODE, ERR_R_EC_LIB);
411         return 0;
412     }
413     EVP_PKEY_assign_EC_KEY(pkey, eckey);
414     return 1;
415 }
416
417 static int eckey_param_encode(const EVP_PKEY *pkey, unsigned char **pder)
418 {
419     return i2d_ECParameters(pkey->pkey.ec, pder);
420 }
421
422 static int eckey_param_print(BIO *bp, const EVP_PKEY *pkey, int indent,
423                              ASN1_PCTX *ctx)
424 {
425     return do_EC_KEY_print(bp, pkey->pkey.ec, indent, EC_KEY_PRINT_PARAM);
426 }
427
428 static int eckey_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
429                            ASN1_PCTX *ctx)
430 {
431     return do_EC_KEY_print(bp, pkey->pkey.ec, indent, EC_KEY_PRINT_PUBLIC);
432 }
433
434 static int eckey_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
435                             ASN1_PCTX *ctx)
436 {
437     return do_EC_KEY_print(bp, pkey->pkey.ec, indent, EC_KEY_PRINT_PRIVATE);
438 }
439
440 static int old_ec_priv_decode(EVP_PKEY *pkey,
441                               const unsigned char **pder, int derlen)
442 {
443     EC_KEY *ec;
444
445     if ((ec = d2i_ECPrivateKey(NULL, pder, derlen)) == NULL) {
446         ECerr(EC_F_OLD_EC_PRIV_DECODE, EC_R_DECODE_ERROR);
447         return 0;
448     }
449     EVP_PKEY_assign_EC_KEY(pkey, ec);
450     return 1;
451 }
452
453 static int old_ec_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
454 {
455     return i2d_ECPrivateKey(pkey->pkey.ec, pder);
456 }
457
458 static int ec_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
459 {
460     switch (op) {
461     case ASN1_PKEY_CTRL_PKCS7_SIGN:
462         if (arg1 == 0) {
463             int snid, hnid;
464             X509_ALGOR *alg1, *alg2;
465             PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, &alg1, &alg2);
466             if (alg1 == NULL || alg1->algorithm == NULL)
467                 return -1;
468             hnid = OBJ_obj2nid(alg1->algorithm);
469             if (hnid == NID_undef)
470                 return -1;
471             if (!OBJ_find_sigid_by_algs(&snid, hnid, EVP_PKEY_id(pkey)))
472                 return -1;
473             X509_ALGOR_set0(alg2, OBJ_nid2obj(snid), V_ASN1_UNDEF, 0);
474         }
475         return 1;
476 #ifndef OPENSSL_NO_CMS
477     case ASN1_PKEY_CTRL_CMS_SIGN:
478         if (arg1 == 0) {
479             int snid, hnid;
480             X509_ALGOR *alg1, *alg2;
481             CMS_SignerInfo_get0_algs(arg2, NULL, NULL, &alg1, &alg2);
482             if (alg1 == NULL || alg1->algorithm == NULL)
483                 return -1;
484             hnid = OBJ_obj2nid(alg1->algorithm);
485             if (hnid == NID_undef)
486                 return -1;
487             if (!OBJ_find_sigid_by_algs(&snid, hnid, EVP_PKEY_id(pkey)))
488                 return -1;
489             X509_ALGOR_set0(alg2, OBJ_nid2obj(snid), V_ASN1_UNDEF, 0);
490         }
491         return 1;
492
493     case ASN1_PKEY_CTRL_CMS_ENVELOPE:
494         if (arg1 == 1)
495             return ecdh_cms_decrypt(arg2);
496         else if (arg1 == 0)
497             return ecdh_cms_encrypt(arg2);
498         return -2;
499
500     case ASN1_PKEY_CTRL_CMS_RI_TYPE:
501         *(int *)arg2 = CMS_RECIPINFO_AGREE;
502         return 1;
503 #endif
504
505     case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
506         *(int *)arg2 = NID_sha256;
507         return 2;
508
509     case ASN1_PKEY_CTRL_SET1_TLS_ENCPT:
510         return EC_KEY_oct2key(EVP_PKEY_get0_EC_KEY(pkey), arg2, arg1, NULL);
511
512     case ASN1_PKEY_CTRL_GET1_TLS_ENCPT:
513         return EC_KEY_key2buf(EVP_PKEY_get0_EC_KEY(pkey),
514                               POINT_CONVERSION_UNCOMPRESSED, arg2, NULL);
515
516     default:
517         return -2;
518
519     }
520
521 }
522
523 static int ec_pkey_check(const EVP_PKEY *pkey)
524 {
525     EC_KEY *eckey = pkey->pkey.ec;
526
527     /* stay consistent to what EVP_PKEY_check demands */
528     if (eckey->priv_key == NULL) {
529         ECerr(EC_F_EC_PKEY_CHECK, EC_R_MISSING_PRIVATE_KEY);
530         return 0;
531     }
532
533     return EC_KEY_check_key(eckey);
534 }
535
536 static int ec_pkey_public_check(const EVP_PKEY *pkey)
537 {
538     EC_KEY *eckey = pkey->pkey.ec;
539
540     /*
541      * Note: it unnecessary to check eckey->pub_key here since
542      * it will be checked in EC_KEY_check_key(). In fact, the
543      * EC_KEY_check_key() mainly checks the public key, and checks
544      * the private key optionally (only if there is one). So if
545      * someone passes a whole EC key (public + private), this
546      * will also work...
547      */
548
549     return EC_KEY_check_key(eckey);
550 }
551
552 static int ec_pkey_param_check(const EVP_PKEY *pkey)
553 {
554     EC_KEY *eckey = pkey->pkey.ec;
555
556     /* stay consistent to what EVP_PKEY_check demands */
557     if (eckey->group == NULL) {
558         ECerr(EC_F_EC_PKEY_PARAM_CHECK, EC_R_MISSING_PARAMETERS);
559         return 0;
560     }
561
562     return EC_GROUP_check(eckey->group, NULL);
563 }
564
565 const EVP_PKEY_ASN1_METHOD eckey_asn1_meth = {
566     EVP_PKEY_EC,
567     EVP_PKEY_EC,
568     0,
569     "EC",
570     "OpenSSL EC algorithm",
571
572     eckey_pub_decode,
573     eckey_pub_encode,
574     eckey_pub_cmp,
575     eckey_pub_print,
576
577     eckey_priv_decode,
578     eckey_priv_encode,
579     eckey_priv_print,
580
581     int_ec_size,
582     ec_bits,
583     ec_security_bits,
584
585     eckey_param_decode,
586     eckey_param_encode,
587     ec_missing_parameters,
588     ec_copy_parameters,
589     ec_cmp_parameters,
590     eckey_param_print,
591     0,
592
593     int_ec_free,
594     ec_pkey_ctrl,
595     old_ec_priv_decode,
596     old_ec_priv_encode,
597
598     0, 0, 0,
599
600     ec_pkey_check,
601     ec_pkey_public_check,
602     ec_pkey_param_check
603 };
604
605 int EC_KEY_print(BIO *bp, const EC_KEY *x, int off)
606 {
607     int private = EC_KEY_get0_private_key(x) != NULL;
608
609     return do_EC_KEY_print(bp, x, off,
610                 private ? EC_KEY_PRINT_PRIVATE : EC_KEY_PRINT_PUBLIC);
611 }
612
613 int ECParameters_print(BIO *bp, const EC_KEY *x)
614 {
615     return do_EC_KEY_print(bp, x, 4, EC_KEY_PRINT_PARAM);
616 }
617
618 #ifndef OPENSSL_NO_CMS
619
620 static int ecdh_cms_set_peerkey(EVP_PKEY_CTX *pctx,
621                                 X509_ALGOR *alg, ASN1_BIT_STRING *pubkey)
622 {
623     const ASN1_OBJECT *aoid;
624     int atype;
625     const void *aval;
626     int rv = 0;
627     EVP_PKEY *pkpeer = NULL;
628     EC_KEY *ecpeer = NULL;
629     const unsigned char *p;
630     int plen;
631     X509_ALGOR_get0(&aoid, &atype, &aval, alg);
632     if (OBJ_obj2nid(aoid) != NID_X9_62_id_ecPublicKey)
633         goto err;
634     /* If absent parameters get group from main key */
635     if (atype == V_ASN1_UNDEF || atype == V_ASN1_NULL) {
636         const EC_GROUP *grp;
637         EVP_PKEY *pk;
638         pk = EVP_PKEY_CTX_get0_pkey(pctx);
639         if (!pk)
640             goto err;
641         grp = EC_KEY_get0_group(pk->pkey.ec);
642         ecpeer = EC_KEY_new();
643         if (ecpeer == NULL)
644             goto err;
645         if (!EC_KEY_set_group(ecpeer, grp))
646             goto err;
647     } else {
648         ecpeer = eckey_type2param(atype, aval);
649         if (!ecpeer)
650             goto err;
651     }
652     /* We have parameters now set public key */
653     plen = ASN1_STRING_length(pubkey);
654     p = ASN1_STRING_get0_data(pubkey);
655     if (!p || !plen)
656         goto err;
657     if (!o2i_ECPublicKey(&ecpeer, &p, plen))
658         goto err;
659     pkpeer = EVP_PKEY_new();
660     if (pkpeer == NULL)
661         goto err;
662     EVP_PKEY_set1_EC_KEY(pkpeer, ecpeer);
663     if (EVP_PKEY_derive_set_peer(pctx, pkpeer) > 0)
664         rv = 1;
665  err:
666     EC_KEY_free(ecpeer);
667     EVP_PKEY_free(pkpeer);
668     return rv;
669 }
670
671 /* Set KDF parameters based on KDF NID */
672 static int ecdh_cms_set_kdf_param(EVP_PKEY_CTX *pctx, int eckdf_nid)
673 {
674     int kdf_nid, kdfmd_nid, cofactor;
675     const EVP_MD *kdf_md;
676     if (eckdf_nid == NID_undef)
677         return 0;
678
679     /* Lookup KDF type, cofactor mode and digest */
680     if (!OBJ_find_sigid_algs(eckdf_nid, &kdfmd_nid, &kdf_nid))
681         return 0;
682
683     if (kdf_nid == NID_dh_std_kdf)
684         cofactor = 0;
685     else if (kdf_nid == NID_dh_cofactor_kdf)
686         cofactor = 1;
687     else
688         return 0;
689
690     if (EVP_PKEY_CTX_set_ecdh_cofactor_mode(pctx, cofactor) <= 0)
691         return 0;
692
693     if (EVP_PKEY_CTX_set_ecdh_kdf_type(pctx, EVP_PKEY_ECDH_KDF_X9_62) <= 0)
694         return 0;
695
696     kdf_md = EVP_get_digestbynid(kdfmd_nid);
697     if (!kdf_md)
698         return 0;
699
700     if (EVP_PKEY_CTX_set_ecdh_kdf_md(pctx, kdf_md) <= 0)
701         return 0;
702     return 1;
703 }
704
705 static int ecdh_cms_set_shared_info(EVP_PKEY_CTX *pctx, CMS_RecipientInfo *ri)
706 {
707     int rv = 0;
708
709     X509_ALGOR *alg, *kekalg = NULL;
710     ASN1_OCTET_STRING *ukm;
711     const unsigned char *p;
712     unsigned char *der = NULL;
713     int plen, keylen;
714     const EVP_CIPHER *kekcipher;
715     EVP_CIPHER_CTX *kekctx;
716
717     if (!CMS_RecipientInfo_kari_get0_alg(ri, &alg, &ukm))
718         return 0;
719
720     if (!ecdh_cms_set_kdf_param(pctx, OBJ_obj2nid(alg->algorithm))) {
721         ECerr(EC_F_ECDH_CMS_SET_SHARED_INFO, EC_R_KDF_PARAMETER_ERROR);
722         return 0;
723     }
724
725     if (alg->parameter->type != V_ASN1_SEQUENCE)
726         return 0;
727
728     p = alg->parameter->value.sequence->data;
729     plen = alg->parameter->value.sequence->length;
730     kekalg = d2i_X509_ALGOR(NULL, &p, plen);
731     if (!kekalg)
732         goto err;
733     kekctx = CMS_RecipientInfo_kari_get0_ctx(ri);
734     if (!kekctx)
735         goto err;
736     kekcipher = EVP_get_cipherbyobj(kekalg->algorithm);
737     if (!kekcipher || EVP_CIPHER_mode(kekcipher) != EVP_CIPH_WRAP_MODE)
738         goto err;
739     if (!EVP_EncryptInit_ex(kekctx, kekcipher, NULL, NULL, NULL))
740         goto err;
741     if (EVP_CIPHER_asn1_to_param(kekctx, kekalg->parameter) <= 0)
742         goto err;
743
744     keylen = EVP_CIPHER_CTX_key_length(kekctx);
745     if (EVP_PKEY_CTX_set_ecdh_kdf_outlen(pctx, keylen) <= 0)
746         goto err;
747
748     plen = CMS_SharedInfo_encode(&der, kekalg, ukm, keylen);
749
750     if (!plen)
751         goto err;
752
753     if (EVP_PKEY_CTX_set0_ecdh_kdf_ukm(pctx, der, plen) <= 0)
754         goto err;
755     der = NULL;
756
757     rv = 1;
758  err:
759     X509_ALGOR_free(kekalg);
760     OPENSSL_free(der);
761     return rv;
762 }
763
764 static int ecdh_cms_decrypt(CMS_RecipientInfo *ri)
765 {
766     EVP_PKEY_CTX *pctx;
767     pctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
768     if (!pctx)
769         return 0;
770     /* See if we need to set peer key */
771     if (!EVP_PKEY_CTX_get0_peerkey(pctx)) {
772         X509_ALGOR *alg;
773         ASN1_BIT_STRING *pubkey;
774         if (!CMS_RecipientInfo_kari_get0_orig_id(ri, &alg, &pubkey,
775                                                  NULL, NULL, NULL))
776             return 0;
777         if (!alg || !pubkey)
778             return 0;
779         if (!ecdh_cms_set_peerkey(pctx, alg, pubkey)) {
780             ECerr(EC_F_ECDH_CMS_DECRYPT, EC_R_PEER_KEY_ERROR);
781             return 0;
782         }
783     }
784     /* Set ECDH derivation parameters and initialise unwrap context */
785     if (!ecdh_cms_set_shared_info(pctx, ri)) {
786         ECerr(EC_F_ECDH_CMS_DECRYPT, EC_R_SHARED_INFO_ERROR);
787         return 0;
788     }
789     return 1;
790 }
791
792 static int ecdh_cms_encrypt(CMS_RecipientInfo *ri)
793 {
794     EVP_PKEY_CTX *pctx;
795     EVP_PKEY *pkey;
796     EVP_CIPHER_CTX *ctx;
797     int keylen;
798     X509_ALGOR *talg, *wrap_alg = NULL;
799     const ASN1_OBJECT *aoid;
800     ASN1_BIT_STRING *pubkey;
801     ASN1_STRING *wrap_str;
802     ASN1_OCTET_STRING *ukm;
803     unsigned char *penc = NULL;
804     int penclen;
805     int rv = 0;
806     int ecdh_nid, kdf_type, kdf_nid, wrap_nid;
807     const EVP_MD *kdf_md;
808     pctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
809     if (!pctx)
810         return 0;
811     /* Get ephemeral key */
812     pkey = EVP_PKEY_CTX_get0_pkey(pctx);
813     if (!CMS_RecipientInfo_kari_get0_orig_id(ri, &talg, &pubkey,
814                                              NULL, NULL, NULL))
815         goto err;
816     X509_ALGOR_get0(&aoid, NULL, NULL, talg);
817     /* Is everything uninitialised? */
818     if (aoid == OBJ_nid2obj(NID_undef)) {
819
820         EC_KEY *eckey = pkey->pkey.ec;
821         /* Set the key */
822         unsigned char *p;
823
824         penclen = i2o_ECPublicKey(eckey, NULL);
825         if (penclen <= 0)
826             goto err;
827         penc = OPENSSL_malloc(penclen);
828         if (penc == NULL)
829             goto err;
830         p = penc;
831         penclen = i2o_ECPublicKey(eckey, &p);
832         if (penclen <= 0)
833             goto err;
834         ASN1_STRING_set0(pubkey, penc, penclen);
835         pubkey->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);
836         pubkey->flags |= ASN1_STRING_FLAG_BITS_LEFT;
837
838         penc = NULL;
839         X509_ALGOR_set0(talg, OBJ_nid2obj(NID_X9_62_id_ecPublicKey),
840                         V_ASN1_UNDEF, NULL);
841     }
842
843     /* See if custom parameters set */
844     kdf_type = EVP_PKEY_CTX_get_ecdh_kdf_type(pctx);
845     if (kdf_type <= 0)
846         goto err;
847     if (!EVP_PKEY_CTX_get_ecdh_kdf_md(pctx, &kdf_md))
848         goto err;
849     ecdh_nid = EVP_PKEY_CTX_get_ecdh_cofactor_mode(pctx);
850     if (ecdh_nid < 0)
851         goto err;
852     else if (ecdh_nid == 0)
853         ecdh_nid = NID_dh_std_kdf;
854     else if (ecdh_nid == 1)
855         ecdh_nid = NID_dh_cofactor_kdf;
856
857     if (kdf_type == EVP_PKEY_ECDH_KDF_NONE) {
858         kdf_type = EVP_PKEY_ECDH_KDF_X9_62;
859         if (EVP_PKEY_CTX_set_ecdh_kdf_type(pctx, kdf_type) <= 0)
860             goto err;
861     } else
862         /* Unknown KDF */
863         goto err;
864     if (kdf_md == NULL) {
865         /* Fixme later for better MD */
866         kdf_md = EVP_sha1();
867         if (EVP_PKEY_CTX_set_ecdh_kdf_md(pctx, kdf_md) <= 0)
868             goto err;
869     }
870
871     if (!CMS_RecipientInfo_kari_get0_alg(ri, &talg, &ukm))
872         goto err;
873
874     /* Lookup NID for KDF+cofactor+digest */
875
876     if (!OBJ_find_sigid_by_algs(&kdf_nid, EVP_MD_type(kdf_md), ecdh_nid))
877         goto err;
878     /* Get wrap NID */
879     ctx = CMS_RecipientInfo_kari_get0_ctx(ri);
880     wrap_nid = EVP_CIPHER_CTX_type(ctx);
881     keylen = EVP_CIPHER_CTX_key_length(ctx);
882
883     /* Package wrap algorithm in an AlgorithmIdentifier */
884
885     wrap_alg = X509_ALGOR_new();
886     if (wrap_alg == NULL)
887         goto err;
888     wrap_alg->algorithm = OBJ_nid2obj(wrap_nid);
889     wrap_alg->parameter = ASN1_TYPE_new();
890     if (wrap_alg->parameter == NULL)
891         goto err;
892     if (EVP_CIPHER_param_to_asn1(ctx, wrap_alg->parameter) <= 0)
893         goto err;
894     if (ASN1_TYPE_get(wrap_alg->parameter) == NID_undef) {
895         ASN1_TYPE_free(wrap_alg->parameter);
896         wrap_alg->parameter = NULL;
897     }
898
899     if (EVP_PKEY_CTX_set_ecdh_kdf_outlen(pctx, keylen) <= 0)
900         goto err;
901
902     penclen = CMS_SharedInfo_encode(&penc, wrap_alg, ukm, keylen);
903
904     if (!penclen)
905         goto err;
906
907     if (EVP_PKEY_CTX_set0_ecdh_kdf_ukm(pctx, penc, penclen) <= 0)
908         goto err;
909     penc = NULL;
910
911     /*
912      * Now need to wrap encoding of wrap AlgorithmIdentifier into parameter
913      * of another AlgorithmIdentifier.
914      */
915     penclen = i2d_X509_ALGOR(wrap_alg, &penc);
916     if (!penc || !penclen)
917         goto err;
918     wrap_str = ASN1_STRING_new();
919     if (wrap_str == NULL)
920         goto err;
921     ASN1_STRING_set0(wrap_str, penc, penclen);
922     penc = NULL;
923     X509_ALGOR_set0(talg, OBJ_nid2obj(kdf_nid), V_ASN1_SEQUENCE, wrap_str);
924
925     rv = 1;
926
927  err:
928     OPENSSL_free(penc);
929     X509_ALGOR_free(wrap_alg);
930     return rv;
931 }
932
933 #endif