ecc: Put the curve name again into the output of gcry_pk_genkey.
[libgcrypt.git] / cipher / ecc.c
1 /* ecc.c  -  Elliptic Curve Cryptography
2  * Copyright (C) 2007, 2008, 2010, 2011 Free Software Foundation, Inc.
3  * Copyright (C) 2013 g10 Code GmbH
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 /* This code is originally based on the Patch 0.1.6 for the gnupg
22    1.4.x branch as retrieved on 2007-03-21 from
23    http://www.calcurco.cat/eccGnuPG/src/gnupg-1.4.6-ecc0.2.0beta1.diff.bz2
24    The original authors are:
25      Written by
26       Sergi Blanch i Torne <d4372211 at alumnes.eup.udl.es>,
27       Ramiro Moreno Chiral <ramiro at eup.udl.es>
28      Maintainers
29       Sergi Blanch i Torne
30       Ramiro Moreno Chiral
31       Mikael Mylnikov (mmr)
32   For use in Libgcrypt the code has been heavily modified and cleaned
33   up. In fact there is not much left of the orginally code except for
34   some variable names and the text book implementaion of the sign and
35   verification algorithms.  The arithmetic functions have entirely
36   been rewritten and moved to mpi/ec.c.
37
38   ECDH encrypt and decrypt code written by Andrey Jivsov,
39 */
40
41
42 /* TODO:
43
44   - If we support point compression we need to uncompress before
45     computing the keygrip
46
47   - In mpi/ec.c we use mpi_powm for x^2 mod p: Either implement a
48     special case in mpi_powm or check whether mpi_mulm is faster.
49
50 */
51
52
53 #include <config.h>
54 #include <stdio.h>
55 #include <stdlib.h>
56 #include <string.h>
57 #include <errno.h>
58
59 #include "g10lib.h"
60 #include "mpi.h"
61 #include "cipher.h"
62 #include "context.h"
63 #include "ec-context.h"
64 #include "pubkey-internal.h"
65 #include "ecc-common.h"
66
67
68 static const char *ecc_names[] =
69   {
70     "ecc",
71     "ecdsa",
72     "ecdh",
73     "eddsa",
74     "gost",
75     NULL,
76   };
77
78
79 /* Registered progress function and its callback value. */
80 static void (*progress_cb) (void *, const char*, int, int, int);
81 static void *progress_cb_data;
82
83
84 #define point_init(a)  _gcry_mpi_point_init ((a))
85 #define point_free(a)  _gcry_mpi_point_free_parts ((a))
86
87 \f
88 /* Local prototypes. */
89 static void test_keys (ECC_secret_key * sk, unsigned int nbits);
90 static int check_secret_key (ECC_secret_key * sk);
91 static gpg_err_code_t sign_ecdsa (gcry_mpi_t input, ECC_secret_key *skey,
92                                   gcry_mpi_t r, gcry_mpi_t s,
93                                   int flags, int hashalgo);
94 static gpg_err_code_t verify_ecdsa (gcry_mpi_t input, ECC_public_key *pkey,
95                                     gcry_mpi_t r, gcry_mpi_t s);
96
97 static gcry_mpi_t gen_y_2 (gcry_mpi_t x, elliptic_curve_t * base);
98 static unsigned int ecc_get_nbits (gcry_sexp_t parms);
99
100
101
102 \f
103 void
104 _gcry_register_pk_ecc_progress (void (*cb) (void *, const char *,
105                                             int, int, int),
106                                 void *cb_data)
107 {
108   progress_cb = cb;
109   progress_cb_data = cb_data;
110 }
111
112 /* static void */
113 /* progress (int c) */
114 /* { */
115 /*   if (progress_cb) */
116 /*     progress_cb (progress_cb_data, "pk_ecc", c, 0, 0); */
117 /* } */
118
119
120 \f
121
122 /*
123  * Solve the right side of the Weierstrass equation.
124  */
125 static gcry_mpi_t
126 gen_y_2 (gcry_mpi_t x, elliptic_curve_t *base)
127 {
128   gcry_mpi_t three, x_3, axb, y;
129
130   three = mpi_alloc_set_ui (3);
131   x_3 = mpi_new (0);
132   axb = mpi_new (0);
133   y   = mpi_new (0);
134
135   mpi_powm (x_3, x, three, base->p);
136   mpi_mulm (axb, base->a, x, base->p);
137   mpi_addm (axb, axb, base->b, base->p);
138   mpi_addm (y, x_3, axb, base->p);
139
140   mpi_free (x_3);
141   mpi_free (axb);
142   mpi_free (three);
143   return y; /* The quadratic value of the coordinate if it exist. */
144 }
145
146
147 /* Standard version of the key generation.  */
148 static gpg_err_code_t
149 nist_generate_key (ECC_secret_key *sk, elliptic_curve_t *E, mpi_ec_t ctx,
150                    gcry_random_level_t random_level, unsigned int nbits)
151 {
152   mpi_point_struct Q;
153
154   point_init (&Q);
155
156   /* Generate a secret.  */
157   sk->d = _gcry_dsa_gen_k (E->n, random_level);
158
159   /* Compute Q.  */
160   _gcry_mpi_ec_mul_point (&Q, sk->d, &E->G, ctx);
161
162   /* Copy the stuff to the key structures. */
163   sk->E.model = E->model;
164   sk->E.dialect = E->dialect;
165   sk->E.p = mpi_copy (E->p);
166   sk->E.a = mpi_copy (E->a);
167   sk->E.b = mpi_copy (E->b);
168   point_init (&sk->E.G);
169   point_set (&sk->E.G, &E->G);
170   sk->E.n = mpi_copy (E->n);
171   point_init (&sk->Q);
172
173   /* We want the Q=(x,y) be a "compliant key" in terms of the
174    * http://tools.ietf.org/html/draft-jivsov-ecc-compact, which simply
175    * means that we choose either Q=(x,y) or -Q=(x,p-y) such that we
176    * end up with the min(y,p-y) as the y coordinate.  Such a public
177    * key allows the most efficient compression: y can simply be
178    * dropped because we know that it's a minimum of the two
179    * possibilities without any loss of security.  */
180   {
181     gcry_mpi_t x, y, p_y;
182     const unsigned int pbits = mpi_get_nbits (E->p);
183
184     x = mpi_new (pbits);
185     y = mpi_new (pbits);
186     p_y = mpi_new (pbits);
187
188     if (_gcry_mpi_ec_get_affine (x, y, &Q, ctx))
189       log_fatal ("ecgen: Failed to get affine coordinates for %s\n", "Q");
190
191     mpi_sub (p_y, E->p, y);     /* p_y = p - y */
192
193     if (mpi_cmp (p_y, y) < 0)   /* p - y < p */
194       {
195         /* We need to end up with -Q; this assures that new Q's y is
196            the smallest one */
197         mpi_sub (sk->d, E->n, sk->d);   /* d = order - d */
198         gcry_mpi_point_snatch_set (&sk->Q, x, p_y, mpi_alloc_set_ui (1));
199
200       if (DBG_CIPHER)
201         log_debug ("ecgen converted Q to a compliant point\n");
202       }
203     else /* p - y >= p */
204       {
205         /* No change is needed exactly 50% of the time: just copy. */
206         point_set (&sk->Q, &Q);
207         if (DBG_CIPHER)
208           log_debug ("ecgen didn't need to convert Q to a compliant point\n");
209
210         mpi_free (p_y);
211         mpi_free (x);
212       }
213     mpi_free (y);
214   }
215
216   /* Now we can test our keys (this should never fail!).  */
217   test_keys (sk, nbits - 64);
218
219   return 0;
220 }
221
222
223 /*
224  * To verify correct skey it use a random information.
225  * First, encrypt and decrypt this dummy value,
226  * test if the information is recuperated.
227  * Second, test with the sign and verify functions.
228  */
229 static void
230 test_keys (ECC_secret_key *sk, unsigned int nbits)
231 {
232   ECC_public_key pk;
233   gcry_mpi_t test = mpi_new (nbits);
234   mpi_point_struct R_;
235   gcry_mpi_t c = mpi_new (nbits);
236   gcry_mpi_t out = mpi_new (nbits);
237   gcry_mpi_t r = mpi_new (nbits);
238   gcry_mpi_t s = mpi_new (nbits);
239
240   if (DBG_CIPHER)
241     log_debug ("Testing key.\n");
242
243   point_init (&R_);
244
245   pk.E = _gcry_ecc_curve_copy (sk->E);
246   point_init (&pk.Q);
247   point_set (&pk.Q, &sk->Q);
248
249   gcry_mpi_randomize (test, nbits, GCRY_WEAK_RANDOM);
250
251   if (sign_ecdsa (test, sk, r, s, 0, 0) )
252     log_fatal ("ECDSA operation: sign failed\n");
253
254   if (verify_ecdsa (test, &pk, r, s))
255     {
256       log_fatal ("ECDSA operation: sign, verify failed\n");
257     }
258
259   if (DBG_CIPHER)
260     log_debug ("ECDSA operation: sign, verify ok.\n");
261
262   point_free (&pk.Q);
263   _gcry_ecc_curve_free (&pk.E);
264
265   point_free (&R_);
266   mpi_free (s);
267   mpi_free (r);
268   mpi_free (out);
269   mpi_free (c);
270   mpi_free (test);
271 }
272
273
274 /*
275  * To check the validity of the value, recalculate the correspondence
276  * between the public value and the secret one.
277  */
278 static int
279 check_secret_key (ECC_secret_key * sk)
280 {
281   int rc = 1;
282   mpi_point_struct Q;
283   gcry_mpi_t y_2, y2;
284   gcry_mpi_t x1, x2;
285   mpi_ec_t ctx = NULL;
286
287   point_init (&Q);
288
289   /* ?primarity test of 'p' */
290   /*  (...) //!! */
291   /* G in E(F_p) */
292   y_2 = gen_y_2 (sk->E.G.x, &sk->E);   /*  y^2=x^3+a*x+b */
293   y2 = mpi_alloc (0);
294   x1 = mpi_alloc (0);
295   x2 = mpi_alloc (0);
296   mpi_mulm (y2, sk->E.G.y, sk->E.G.y, sk->E.p);      /*  y^2=y*y */
297   if (mpi_cmp (y_2, y2))
298     {
299       if (DBG_CIPHER)
300         log_debug ("Bad check: Point 'G' does not belong to curve 'E'!\n");
301       goto leave;
302     }
303   /* G != PaI */
304   if (!mpi_cmp_ui (sk->E.G.z, 0))
305     {
306       if (DBG_CIPHER)
307         log_debug ("Bad check: 'G' cannot be Point at Infinity!\n");
308       goto leave;
309     }
310
311   ctx = _gcry_mpi_ec_p_internal_new (sk->E.model, sk->E.dialect,
312                                      sk->E.p, sk->E.a, sk->E.b);
313
314   _gcry_mpi_ec_mul_point (&Q, sk->E.n, &sk->E.G, ctx);
315   if (mpi_cmp_ui (Q.z, 0))
316     {
317       if (DBG_CIPHER)
318         log_debug ("check_secret_key: E is not a curve of order n\n");
319       goto leave;
320     }
321   /* pubkey cannot be PaI */
322   if (!mpi_cmp_ui (sk->Q.z, 0))
323     {
324       if (DBG_CIPHER)
325         log_debug ("Bad check: Q can not be a Point at Infinity!\n");
326       goto leave;
327     }
328   /* pubkey = [d]G over E */
329   _gcry_mpi_ec_mul_point (&Q, sk->d, &sk->E.G, ctx);
330
331   if (_gcry_mpi_ec_get_affine (x1, y_2, &Q, ctx))
332     {
333       if (DBG_CIPHER)
334         log_debug ("Bad check: Q can not be a Point at Infinity!\n");
335       goto leave;
336     }
337
338   /* Fast path for loaded secret keys - Q is already in affine coordinates */
339   if (!mpi_cmp_ui (sk->Q.z, 1))
340     {
341       if (mpi_cmp (x1, sk->Q.x) || mpi_cmp (y_2, sk->Q.y))
342         {
343           if (DBG_CIPHER)
344             log_debug
345               ("Bad check: There is NO correspondence between 'd' and 'Q'!\n");
346           goto leave;
347         }
348     }
349   else
350     {
351       if (_gcry_mpi_ec_get_affine (x2, y2, &sk->Q, ctx))
352         {
353           if (DBG_CIPHER)
354             log_debug ("Bad check: Q can not be a Point at Infinity!\n");
355           goto leave;
356         }
357
358       if (mpi_cmp (x1, x2) || mpi_cmp (y_2, y2))
359         {
360           if (DBG_CIPHER)
361             log_debug
362               ("Bad check: There is NO correspondence between 'd' and 'Q'!\n");
363           goto leave;
364         }
365     }
366   rc = 0; /* Okay.  */
367
368  leave:
369   _gcry_mpi_ec_free (ctx);
370   mpi_free (x2);
371   mpi_free (x1);
372   mpi_free (y2);
373   mpi_free (y_2);
374   point_free (&Q);
375   return rc;
376 }
377
378
379 /* Compute an ECDSA signature.
380  * Return the signature struct (r,s) from the message hash.  The caller
381  * must have allocated R and S.
382  */
383 static gpg_err_code_t
384 sign_ecdsa (gcry_mpi_t input, ECC_secret_key *skey, gcry_mpi_t r, gcry_mpi_t s,
385             int flags, int hashalgo)
386 {
387   gpg_err_code_t err = 0;
388   int extraloops = 0;
389   gcry_mpi_t k, dr, sum, k_1, x;
390   mpi_point_struct I;
391   gcry_mpi_t hash;
392   const void *abuf;
393   unsigned int abits, qbits;
394   mpi_ec_t ctx;
395
396   if (DBG_CIPHER)
397     log_mpidump ("ecdsa sign hash  ", input );
398
399   qbits = mpi_get_nbits (skey->E.n);
400
401   /* Convert the INPUT into an MPI if needed.  */
402   if (mpi_is_opaque (input))
403     {
404       abuf = gcry_mpi_get_opaque (input, &abits);
405       err = gpg_err_code (gcry_mpi_scan (&hash, GCRYMPI_FMT_USG,
406                                          abuf, (abits+7)/8, NULL));
407       if (err)
408         return err;
409       if (abits > qbits)
410         gcry_mpi_rshift (hash, hash, abits - qbits);
411     }
412   else
413     hash = input;
414
415
416   k = NULL;
417   dr = mpi_alloc (0);
418   sum = mpi_alloc (0);
419   k_1 = mpi_alloc (0);
420   x = mpi_alloc (0);
421   point_init (&I);
422
423   ctx = _gcry_mpi_ec_p_internal_new (skey->E.model, skey->E.dialect,
424                                      skey->E.p, skey->E.a, skey->E.b);
425
426   /* Two loops to avoid R or S are zero.  This is more of a joke than
427      a real demand because the probability of them being zero is less
428      than any hardware failure.  Some specs however require it.  */
429   do
430     {
431       do
432         {
433           mpi_free (k);
434           k = NULL;
435           if ((flags & PUBKEY_FLAG_RFC6979) && hashalgo)
436             {
437               /* Use Pornin's method for deterministic DSA.  If this
438                  flag is set, it is expected that HASH is an opaque
439                  MPI with the to be signed hash.  That hash is also
440                  used as h1 from 3.2.a.  */
441               if (!mpi_is_opaque (input))
442                 {
443                   err = GPG_ERR_CONFLICT;
444                   goto leave;
445                 }
446
447               abuf = gcry_mpi_get_opaque (input, &abits);
448               err = _gcry_dsa_gen_rfc6979_k (&k, skey->E.n, skey->d,
449                                              abuf, (abits+7)/8,
450                                              hashalgo, extraloops);
451               if (err)
452                 goto leave;
453               extraloops++;
454             }
455           else
456             k = _gcry_dsa_gen_k (skey->E.n, GCRY_STRONG_RANDOM);
457
458           _gcry_mpi_ec_mul_point (&I, k, &skey->E.G, ctx);
459           if (_gcry_mpi_ec_get_affine (x, NULL, &I, ctx))
460             {
461               if (DBG_CIPHER)
462                 log_debug ("ecc sign: Failed to get affine coordinates\n");
463               err = GPG_ERR_BAD_SIGNATURE;
464               goto leave;
465             }
466           mpi_mod (r, x, skey->E.n);  /* r = x mod n */
467         }
468       while (!mpi_cmp_ui (r, 0));
469
470       mpi_mulm (dr, skey->d, r, skey->E.n); /* dr = d*r mod n  */
471       mpi_addm (sum, hash, dr, skey->E.n);  /* sum = hash + (d*r) mod n  */
472       mpi_invm (k_1, k, skey->E.n);         /* k_1 = k^(-1) mod n  */
473       mpi_mulm (s, k_1, sum, skey->E.n);    /* s = k^(-1)*(hash+(d*r)) mod n */
474     }
475   while (!mpi_cmp_ui (s, 0));
476
477   if (DBG_CIPHER)
478     {
479       log_mpidump ("ecdsa sign result r ", r);
480       log_mpidump ("ecdsa sign result s ", s);
481     }
482
483  leave:
484   _gcry_mpi_ec_free (ctx);
485   point_free (&I);
486   mpi_free (x);
487   mpi_free (k_1);
488   mpi_free (sum);
489   mpi_free (dr);
490   mpi_free (k);
491
492   if (hash != input)
493     mpi_free (hash);
494
495   return err;
496 }
497
498
499 /* Verify an ECDSA signature.
500  * Check if R and S verifies INPUT.
501  */
502 static gpg_err_code_t
503 verify_ecdsa (gcry_mpi_t input, ECC_public_key *pkey,
504               gcry_mpi_t r, gcry_mpi_t s)
505 {
506   gpg_err_code_t err = 0;
507   gcry_mpi_t h, h1, h2, x;
508   mpi_point_struct Q, Q1, Q2;
509   mpi_ec_t ctx;
510
511   if( !(mpi_cmp_ui (r, 0) > 0 && mpi_cmp (r, pkey->E.n) < 0) )
512     return GPG_ERR_BAD_SIGNATURE; /* Assertion  0 < r < n  failed.  */
513   if( !(mpi_cmp_ui (s, 0) > 0 && mpi_cmp (s, pkey->E.n) < 0) )
514     return GPG_ERR_BAD_SIGNATURE; /* Assertion  0 < s < n  failed.  */
515
516   h  = mpi_alloc (0);
517   h1 = mpi_alloc (0);
518   h2 = mpi_alloc (0);
519   x = mpi_alloc (0);
520   point_init (&Q);
521   point_init (&Q1);
522   point_init (&Q2);
523
524   ctx = _gcry_mpi_ec_p_internal_new (pkey->E.model, pkey->E.dialect,
525                                      pkey->E.p, pkey->E.a, pkey->E.b);
526
527   /* h  = s^(-1) (mod n) */
528   mpi_invm (h, s, pkey->E.n);
529   /* h1 = hash * s^(-1) (mod n) */
530   mpi_mulm (h1, input, h, pkey->E.n);
531   /* Q1 = [ hash * s^(-1) ]G  */
532   _gcry_mpi_ec_mul_point (&Q1, h1, &pkey->E.G, ctx);
533   /* h2 = r * s^(-1) (mod n) */
534   mpi_mulm (h2, r, h, pkey->E.n);
535   /* Q2 = [ r * s^(-1) ]Q */
536   _gcry_mpi_ec_mul_point (&Q2, h2, &pkey->Q, ctx);
537   /* Q  = ([hash * s^(-1)]G) + ([r * s^(-1)]Q) */
538   _gcry_mpi_ec_add_points (&Q, &Q1, &Q2, ctx);
539
540   if (!mpi_cmp_ui (Q.z, 0))
541     {
542       if (DBG_CIPHER)
543           log_debug ("ecc verify: Rejected\n");
544       err = GPG_ERR_BAD_SIGNATURE;
545       goto leave;
546     }
547   if (_gcry_mpi_ec_get_affine (x, NULL, &Q, ctx))
548     {
549       if (DBG_CIPHER)
550         log_debug ("ecc verify: Failed to get affine coordinates\n");
551       err = GPG_ERR_BAD_SIGNATURE;
552       goto leave;
553     }
554   mpi_mod (x, x, pkey->E.n); /* x = x mod E_n */
555   if (mpi_cmp (x, r))   /* x != r */
556     {
557       if (DBG_CIPHER)
558         {
559           log_mpidump ("     x", x);
560           log_mpidump ("     r", r);
561           log_mpidump ("     s", s);
562         }
563       err = GPG_ERR_BAD_SIGNATURE;
564       goto leave;
565     }
566
567  leave:
568   _gcry_mpi_ec_free (ctx);
569   point_free (&Q2);
570   point_free (&Q1);
571   point_free (&Q);
572   mpi_free (x);
573   mpi_free (h2);
574   mpi_free (h1);
575   mpi_free (h);
576   return err;
577 }
578
579 /* Compute an GOST R 34.10-01/-12 signature.
580  * Return the signature struct (r,s) from the message hash.  The caller
581  * must have allocated R and S.
582  */
583 static gpg_err_code_t
584 sign_gost (gcry_mpi_t input, ECC_secret_key *skey, gcry_mpi_t r, gcry_mpi_t s)
585 {
586   gpg_err_code_t err = 0;
587   gcry_mpi_t k, dr, sum, ke, x, e;
588   mpi_point_struct I;
589   gcry_mpi_t hash;
590   const void *abuf;
591   unsigned int abits, qbits;
592   mpi_ec_t ctx;
593
594   if (DBG_CIPHER)
595     log_mpidump ("gost sign hash  ", input );
596
597   qbits = mpi_get_nbits (skey->E.n);
598
599   /* Convert the INPUT into an MPI if needed.  */
600   if (mpi_is_opaque (input))
601     {
602       abuf = gcry_mpi_get_opaque (input, &abits);
603       err = gpg_err_code (gcry_mpi_scan (&hash, GCRYMPI_FMT_USG,
604                                          abuf, (abits+7)/8, NULL));
605       if (err)
606         return err;
607       if (abits > qbits)
608         gcry_mpi_rshift (hash, hash, abits - qbits);
609     }
610   else
611     hash = input;
612
613
614   k = NULL;
615   dr = mpi_alloc (0);
616   sum = mpi_alloc (0);
617   ke = mpi_alloc (0);
618   e = mpi_alloc (0);
619   x = mpi_alloc (0);
620   point_init (&I);
621
622   ctx = _gcry_mpi_ec_p_internal_new (skey->E.model, skey->E.dialect,
623                                      skey->E.p, skey->E.a, skey->E.b);
624
625   mpi_mod (e, input, skey->E.n); /* e = hash mod n */
626
627   if (!mpi_cmp_ui (e, 0))
628     mpi_set_ui (e, 1);
629
630   /* Two loops to avoid R or S are zero.  This is more of a joke than
631      a real demand because the probability of them being zero is less
632      than any hardware failure.  Some specs however require it.  */
633   do
634     {
635       do
636         {
637           mpi_free (k);
638           k = _gcry_dsa_gen_k (skey->E.n, GCRY_STRONG_RANDOM);
639
640           _gcry_mpi_ec_mul_point (&I, k, &skey->E.G, ctx);
641           if (_gcry_mpi_ec_get_affine (x, NULL, &I, ctx))
642             {
643               if (DBG_CIPHER)
644                 log_debug ("ecc sign: Failed to get affine coordinates\n");
645               err = GPG_ERR_BAD_SIGNATURE;
646               goto leave;
647             }
648           mpi_mod (r, x, skey->E.n);  /* r = x mod n */
649         }
650       while (!mpi_cmp_ui (r, 0));
651       mpi_mulm (dr, skey->d, r, skey->E.n); /* dr = d*r mod n  */
652       mpi_mulm (ke, k, e, skey->E.n); /* ke = k*e mod n */
653       mpi_addm (s, ke, dr, skey->E.n); /* sum = (k*e+ d*r) mod n  */
654     }
655   while (!mpi_cmp_ui (s, 0));
656
657   if (DBG_CIPHER)
658     {
659       log_mpidump ("gost sign result r ", r);
660       log_mpidump ("gost sign result s ", s);
661     }
662
663  leave:
664   _gcry_mpi_ec_free (ctx);
665   point_free (&I);
666   mpi_free (x);
667   mpi_free (e);
668   mpi_free (ke);
669   mpi_free (sum);
670   mpi_free (dr);
671   mpi_free (k);
672
673   if (hash != input)
674     mpi_free (hash);
675
676   return err;
677 }
678
679 /* Verify a GOST R 34.10-01/-12 signature.
680  * Check if R and S verifies INPUT.
681  */
682 static gpg_err_code_t
683 verify_gost (gcry_mpi_t input, ECC_public_key *pkey,
684               gcry_mpi_t r, gcry_mpi_t s)
685 {
686   gpg_err_code_t err = 0;
687   gcry_mpi_t e, x, z1, z2, v, rv, zero;
688   mpi_point_struct Q, Q1, Q2;
689   mpi_ec_t ctx;
690
691   if( !(mpi_cmp_ui (r, 0) > 0 && mpi_cmp (r, pkey->E.n) < 0) )
692     return GPG_ERR_BAD_SIGNATURE; /* Assertion  0 < r < n  failed.  */
693   if( !(mpi_cmp_ui (s, 0) > 0 && mpi_cmp (s, pkey->E.n) < 0) )
694     return GPG_ERR_BAD_SIGNATURE; /* Assertion  0 < s < n  failed.  */
695
696   x = mpi_alloc (0);
697   e = mpi_alloc (0);
698   z1 = mpi_alloc (0);
699   z2 = mpi_alloc (0);
700   v = mpi_alloc (0);
701   rv = mpi_alloc (0);
702   zero = mpi_alloc (0);
703
704   point_init (&Q);
705   point_init (&Q1);
706   point_init (&Q2);
707
708   ctx = _gcry_mpi_ec_p_internal_new (pkey->E.model, pkey->E.dialect,
709                                      pkey->E.p, pkey->E.a, pkey->E.b);
710
711   mpi_mod (e, input, pkey->E.n); /* e = hash mod n */
712   if (!mpi_cmp_ui (e, 0))
713     mpi_set_ui (e, 1);
714   mpi_invm (v, e, pkey->E.n); /* v = e^(-1) (mod n) */
715   mpi_mulm (z1, s, v, pkey->E.n); /* z1 = s*v (mod n) */
716   mpi_mulm (rv, r, v, pkey->E.n); /* rv = s*v (mod n) */
717   mpi_subm (z2, zero, rv, pkey->E.n); /* z2 = -r*v (mod n) */
718
719   _gcry_mpi_ec_mul_point (&Q1, z1, &pkey->E.G, ctx);
720 /*   log_mpidump ("Q1.x", Q1.x); */
721 /*   log_mpidump ("Q1.y", Q1.y); */
722 /*   log_mpidump ("Q1.z", Q1.z); */
723   _gcry_mpi_ec_mul_point (&Q2, z2, &pkey->Q, ctx);
724 /*   log_mpidump ("Q2.x", Q2.x); */
725 /*   log_mpidump ("Q2.y", Q2.y); */
726 /*   log_mpidump ("Q2.z", Q2.z); */
727   _gcry_mpi_ec_add_points (&Q, &Q1, &Q2, ctx);
728 /*   log_mpidump (" Q.x", Q.x); */
729 /*   log_mpidump (" Q.y", Q.y); */
730 /*   log_mpidump (" Q.z", Q.z); */
731
732   if (!mpi_cmp_ui (Q.z, 0))
733     {
734       if (DBG_CIPHER)
735           log_debug ("ecc verify: Rejected\n");
736       err = GPG_ERR_BAD_SIGNATURE;
737       goto leave;
738     }
739   if (_gcry_mpi_ec_get_affine (x, NULL, &Q, ctx))
740     {
741       if (DBG_CIPHER)
742         log_debug ("ecc verify: Failed to get affine coordinates\n");
743       err = GPG_ERR_BAD_SIGNATURE;
744       goto leave;
745     }
746   mpi_mod (x, x, pkey->E.n); /* x = x mod E_n */
747   if (mpi_cmp (x, r))   /* x != r */
748     {
749       if (DBG_CIPHER)
750         {
751           log_mpidump ("     x", x);
752           log_mpidump ("     r", r);
753           log_mpidump ("     s", s);
754           log_debug ("ecc verify: Not verified\n");
755         }
756       err = GPG_ERR_BAD_SIGNATURE;
757       goto leave;
758     }
759   if (DBG_CIPHER)
760     log_debug ("ecc verify: Accepted\n");
761
762  leave:
763   _gcry_mpi_ec_free (ctx);
764   point_free (&Q2);
765   point_free (&Q1);
766   point_free (&Q);
767   mpi_free (zero);
768   mpi_free (rv);
769   mpi_free (v);
770   mpi_free (z2);
771   mpi_free (z1);
772   mpi_free (x);
773   mpi_free (e);
774   return err;
775 }
776
777 \f
778 static void
779 reverse_buffer (unsigned char *buffer, unsigned int length)
780 {
781   unsigned int tmp, i;
782
783   for (i=0; i < length/2; i++)
784     {
785       tmp = buffer[i];
786       buffer[i] = buffer[length-1-i];
787       buffer[length-1-i] = tmp;
788     }
789 }
790
791
792 /* Encode MPI using the EdDSA scheme.  MINLEN specifies the required
793    length of the buffer in bytes.  On success 0 is returned an a
794    malloced buffer with the encoded point is stored at R_BUFFER; the
795    length of this buffer is stored at R_BUFLEN.  */
796 static gpg_err_code_t
797 eddsa_encodempi (gcry_mpi_t mpi, unsigned int minlen,
798                  unsigned char **r_buffer, unsigned int *r_buflen)
799 {
800   unsigned char *rawmpi;
801   unsigned int rawmpilen;
802
803   rawmpi = _gcry_mpi_get_buffer (mpi, minlen, &rawmpilen, NULL);
804   if (!rawmpi)
805     return gpg_err_code_from_syserror ();
806
807   *r_buffer = rawmpi;
808   *r_buflen = rawmpilen;
809   return 0;
810 }
811
812
813 /* Encode (X,Y) using the EdDSA scheme.  MINLEN is the required length
814    in bytes for the result.  On success 0 is returned and a malloced
815    buffer with the encoded point is stored at R_BUFFER; the length of
816    this buffer is stored at R_BUFLEN.  */
817 static gpg_err_code_t
818 eddsa_encode_x_y (gcry_mpi_t x, gcry_mpi_t y, unsigned int minlen,
819                   unsigned char **r_buffer, unsigned int *r_buflen)
820 {
821   unsigned char *rawmpi;
822   unsigned int rawmpilen;
823
824   rawmpi = _gcry_mpi_get_buffer (y, minlen, &rawmpilen, NULL);
825   if (!rawmpi)
826     return gpg_err_code_from_syserror ();
827   if (mpi_test_bit (x, 0) && rawmpilen)
828     rawmpi[rawmpilen - 1] |= 0x80;  /* Set sign bit.  */
829
830   *r_buffer = rawmpi;
831   *r_buflen = rawmpilen;
832   return 0;
833 }
834
835 /* Encode POINT using the EdDSA scheme.  X and Y are either scratch
836    variables supplied by the caller or NULL.  CTX is the usual
837    context.  On success 0 is returned and a malloced buffer with the
838    encoded point is stored at R_BUFFER; the length of this buffer is
839    stored at R_BUFLEN.  */
840 gpg_err_code_t
841 _gcry_ecc_eddsa_encodepoint (mpi_point_t point, mpi_ec_t ec,
842                              gcry_mpi_t x_in, gcry_mpi_t y_in,
843                              unsigned char **r_buffer, unsigned int *r_buflen)
844 {
845   gpg_err_code_t rc;
846   gcry_mpi_t x, y;
847
848   x = x_in? x_in : mpi_new (0);
849   y = y_in? y_in : mpi_new (0);
850
851   if (_gcry_mpi_ec_get_affine (x, y, point, ec))
852     {
853       log_error ("eddsa_encodepoint: Failed to get affine coordinates\n");
854       rc = GPG_ERR_INTERNAL;
855     }
856   else
857     rc = eddsa_encode_x_y (x, y, ec->nbits/8, r_buffer, r_buflen);
858
859   if (!x_in)
860     mpi_free (x);
861   if (!y_in)
862     mpi_free (y);
863   return rc;
864 }
865
866
867 /* Decode the EdDSA style encoded PK and set it into RESULT.  CTX is
868    the usual curve context.  If R_ENCPK is not NULL, the encoded PK is
869    stored at that address; this is a new copy to be released by the
870    caller.  In contrast to the supplied PK, this is not an MPI and
871    thus guarnateed to be properly padded.  R_ENCPKLEN received the
872    length of that encoded key.  */
873 gpg_err_code_t
874 _gcry_ecc_eddsa_decodepoint (gcry_mpi_t pk, mpi_ec_t ctx, mpi_point_t result,
875                              unsigned char **r_encpk, unsigned int *r_encpklen)
876 {
877   gpg_err_code_t rc;
878   unsigned char *rawmpi;
879   unsigned int rawmpilen;
880   gcry_mpi_t yy, t, x, p1, p2, p3;
881   int sign;
882
883   if (mpi_is_opaque (pk))
884     {
885       const unsigned char *buf;
886
887       buf = gcry_mpi_get_opaque (pk, &rawmpilen);
888       if (!buf)
889         return GPG_ERR_INV_OBJ;
890       rawmpilen = (rawmpilen + 7)/8;
891
892       /* First check whether the public key has been given in standard
893          uncompressed format.  No need to recover x in this case.
894          Detection is easy: The size of the buffer will be odd and the
895          first byte be 0x04.  */
896       if (rawmpilen > 1 && buf[0] == 0x04 && (rawmpilen%2))
897         {
898           gcry_mpi_t y;
899
900           rc = gcry_mpi_scan (&x, GCRYMPI_FMT_STD,
901                               buf+1, (rawmpilen-1)/2, NULL);
902           if (rc)
903             return rc;
904           rc = gcry_mpi_scan (&y, GCRYMPI_FMT_STD,
905                               buf+1+(rawmpilen-1)/2, (rawmpilen-1)/2, NULL);
906           if (rc)
907             {
908               mpi_free (x);
909               return rc;
910             }
911
912           if (r_encpk)
913             {
914               rc = eddsa_encode_x_y (x, y, ctx->nbits/8, r_encpk, r_encpklen);
915               if (rc)
916                 {
917                   mpi_free (x);
918                   mpi_free (y);
919                   return rc;
920                 }
921             }
922           mpi_snatch (result->x, x);
923           mpi_snatch (result->y, y);
924           mpi_set_ui (result->z, 1);
925           return 0;
926         }
927
928       /* EdDSA compressed point.  */
929       rawmpi = gcry_malloc (rawmpilen? rawmpilen:1);
930       if (!rawmpi)
931         return gpg_err_code_from_syserror ();
932       memcpy (rawmpi, buf, rawmpilen);
933       reverse_buffer (rawmpi, rawmpilen);
934     }
935   else
936     {
937       /* Note: Without using an opaque MPI it is not reliable possible
938          to find out whether the public key has been given in
939          uncompressed format.  Thus we expect EdDSA format here.  */
940       rawmpi = _gcry_mpi_get_buffer (pk, ctx->nbits/8, &rawmpilen, NULL);
941       if (!rawmpi)
942         return gpg_err_code_from_syserror ();
943     }
944
945   if (rawmpilen)
946     {
947       sign = !!(rawmpi[0] & 0x80);
948       rawmpi[0] &= 0x7f;
949     }
950   else
951     sign = 0;
952   _gcry_mpi_set_buffer (result->y, rawmpi, rawmpilen, 0);
953   if (r_encpk)
954     {
955       /* Revert to little endian.  */
956       if (sign && rawmpilen)
957         rawmpi[0] |= 0x80;
958       reverse_buffer (rawmpi, rawmpilen);
959       *r_encpk = rawmpi;
960       if (r_encpklen)
961         *r_encpklen = rawmpilen;
962     }
963   else
964     gcry_free (rawmpi);
965
966   /* Now recover X.  */
967   /* t = (y^2-1) · ((b*y^2+1)^{p-2} mod p) */
968   x = mpi_new (0);
969   yy = mpi_new (0);
970   mpi_mul (yy, result->y, result->y);
971   t = mpi_copy (yy);
972   mpi_mul (t, t, ctx->b);
973   mpi_add_ui (t, t, 1);
974   p2 = mpi_copy (ctx->p);
975   mpi_sub_ui (p2, p2, 2);
976   mpi_powm (t, t, p2, ctx->p);
977
978   mpi_sub_ui (yy, yy, 1);
979   mpi_mul (t, yy, t);
980
981   /* x = t^{(p+3)/8} mod p */
982   p3 = mpi_copy (ctx->p);
983   mpi_add_ui (p3, p3, 3);
984   mpi_fdiv_q (p3, p3, mpi_const (MPI_C_EIGHT));
985   mpi_powm (x, t, p3, ctx->p);
986
987   /* (x^2 - t) % p != 0 ? x = (x*(2^{(p-1)/4} mod p)) % p */
988   mpi_mul (yy, x, x);
989   mpi_subm (yy, yy, t, ctx->p);
990   if (mpi_cmp_ui (yy, 0))
991     {
992       p1 = mpi_copy (ctx->p);
993       mpi_sub_ui (p1, p1, 1);
994       mpi_fdiv_q (p1, p1, mpi_const (MPI_C_FOUR));
995       mpi_powm (yy, mpi_const (MPI_C_TWO), p1, ctx->p);
996       mpi_mulm (x, x, yy, ctx->p);
997     }
998   else
999     p1 = NULL;
1000
1001   /* is_odd(x) ? x = p-x */
1002   if (mpi_test_bit (x, 0))
1003     mpi_sub (x, ctx->p, x);
1004
1005   /* lowbit(x) != highbit(input) ?  x = p-x */
1006   if (mpi_test_bit (x, 0) != sign)
1007     mpi_sub (x, ctx->p, x);
1008
1009   mpi_set (result->x, x);
1010   mpi_set_ui (result->z, 1);
1011
1012   gcry_mpi_release (x);
1013   gcry_mpi_release (yy);
1014   gcry_mpi_release (t);
1015   gcry_mpi_release (p3);
1016   gcry_mpi_release (p2);
1017   gcry_mpi_release (p1);
1018
1019   return 0;
1020 }
1021
1022
1023 /* Ed25519 version of the key generation.  */
1024 static gpg_err_code_t
1025 eddsa_generate_key (ECC_secret_key *sk, elliptic_curve_t *E, mpi_ec_t ctx,
1026                     gcry_random_level_t random_level)
1027 {
1028   gpg_err_code_t rc;
1029   int b = 256/8;             /* The only size we currently support.  */
1030   gcry_mpi_t a, x, y;
1031   mpi_point_struct Q;
1032   char *dbuf;
1033   size_t dlen;
1034   gcry_buffer_t hvec[1];
1035   unsigned char *hash_d = NULL;
1036
1037   point_init (&Q);
1038   memset (hvec, 0, sizeof hvec);
1039
1040   a = mpi_snew (0);
1041   x = mpi_new (0);
1042   y = mpi_new (0);
1043
1044   /* Generate a secret.  */
1045   hash_d = gcry_malloc_secure (2*b);
1046   if (!hash_d)
1047     {
1048       rc = gpg_error_from_syserror ();
1049       goto leave;
1050     }
1051   dlen = b;
1052   dbuf = gcry_random_bytes_secure (dlen, random_level);
1053
1054   /* Compute the A value.  */
1055   hvec[0].data = dbuf;
1056   hvec[0].len = dlen;
1057   rc = _gcry_md_hash_buffers (GCRY_MD_SHA512, 0, hash_d, hvec, 1);
1058   if (rc)
1059     goto leave;
1060   sk->d = _gcry_mpi_set_opaque (NULL, dbuf, dlen*8);
1061   dbuf = NULL;
1062   reverse_buffer (hash_d, 32);  /* Only the first half of the hash.  */
1063   hash_d[0] = (hash_d[0] & 0x7f) | 0x40;
1064   hash_d[31] &= 0xf8;
1065   _gcry_mpi_set_buffer (a, hash_d, 32, 0);
1066   gcry_free (hash_d); hash_d = NULL;
1067   /* log_printmpi ("ecgen         a", a); */
1068
1069   /* Compute Q.  */
1070   _gcry_mpi_ec_mul_point (&Q, a, &E->G, ctx);
1071   if (DBG_CIPHER)
1072     log_printpnt ("ecgen      pk", &Q, ctx);
1073
1074   /* Copy the stuff to the key structures. */
1075   sk->E.model = E->model;
1076   sk->E.dialect = E->dialect;
1077   sk->E.p = mpi_copy (E->p);
1078   sk->E.a = mpi_copy (E->a);
1079   sk->E.b = mpi_copy (E->b);
1080   point_init (&sk->E.G);
1081   point_set (&sk->E.G, &E->G);
1082   sk->E.n = mpi_copy (E->n);
1083   point_init (&sk->Q);
1084   point_set (&sk->Q, &Q);
1085
1086  leave:
1087   gcry_mpi_release (a);
1088   gcry_mpi_release (x);
1089   gcry_mpi_release (y);
1090   gcry_free (hash_d);
1091   return rc;
1092 }
1093
1094
1095 /* Compute an EdDSA signature. See:
1096  *   [ed25519] 23pp. (PDF) Daniel J. Bernstein, Niels Duif, Tanja
1097  *   Lange, Peter Schwabe, Bo-Yin Yang. High-speed high-security
1098  *   signatures.  Journal of Cryptographic Engineering 2 (2012), 77-89.
1099  *   Document ID: a1a62a2f76d23f65d622484ddd09caf8.
1100  *   URL: http://cr.yp.to/papers.html#ed25519. Date: 2011.09.26.
1101  *
1102  * Despite that this function requires the specification of a hash
1103  * algorithm, we only support what has been specified by the paper.
1104  * This may change in the future.  Note that we don't check the used
1105  * curve; the user is responsible to use Ed25519.
1106  *
1107  * Return the signature struct (r,s) from the message hash.  The caller
1108  * must have allocated R_R and S.
1109  */
1110 static gpg_err_code_t
1111 sign_eddsa (gcry_mpi_t input, ECC_secret_key *skey,
1112             gcry_mpi_t r_r, gcry_mpi_t s, int hashalgo, gcry_mpi_t pk)
1113 {
1114   int rc;
1115   mpi_ec_t ctx = NULL;
1116   int b;
1117   unsigned int tmp;
1118   unsigned char *digest;
1119   gcry_buffer_t hvec[3];
1120   const void *mbuf;
1121   size_t mlen;
1122   unsigned char *rawmpi = NULL;
1123   unsigned int rawmpilen;
1124   unsigned char *encpk = NULL; /* Encoded public key.  */
1125   unsigned int encpklen;
1126   mpi_point_struct I;          /* Intermediate value.  */
1127   mpi_point_struct Q;          /* Public key.  */
1128   gcry_mpi_t a, x, y, r;
1129
1130   memset (hvec, 0, sizeof hvec);
1131
1132   if (!mpi_is_opaque (input))
1133     return GPG_ERR_INV_DATA;
1134   if (hashalgo != GCRY_MD_SHA512)
1135     return GPG_ERR_DIGEST_ALGO;
1136
1137   /* Initialize some helpers.  */
1138   point_init (&I);
1139   point_init (&Q);
1140   a = mpi_snew (0);
1141   x = mpi_new (0);
1142   y = mpi_new (0);
1143   r = mpi_new (0);
1144   ctx = _gcry_mpi_ec_p_internal_new (skey->E.model, skey->E.dialect,
1145                                      skey->E.p, skey->E.a, skey->E.b);
1146   b = (ctx->nbits+7)/8;
1147   if (b != 256/8)
1148     return GPG_ERR_INTERNAL; /* We only support 256 bit. */
1149
1150   digest = gcry_calloc_secure (2, b);
1151   if (!digest)
1152     {
1153       rc = gpg_err_code_from_syserror ();
1154       goto leave;
1155     }
1156
1157   /* Hash the secret key.  We clear DIGEST so we can use it as input
1158      to left pad the key with zeroes for hashing.  */
1159   rawmpi = _gcry_mpi_get_buffer (skey->d, 0, &rawmpilen, NULL);
1160   if (!rawmpi)
1161     {
1162       rc = gpg_err_code_from_syserror ();
1163       goto leave;
1164     }
1165   hvec[0].data = digest;
1166   hvec[0].off = 0;
1167   hvec[0].len = b > rawmpilen? b - rawmpilen : 0;
1168   hvec[1].data = rawmpi;
1169   hvec[1].off = 0;
1170   hvec[1].len = rawmpilen;
1171   rc = _gcry_md_hash_buffers (hashalgo, 0, digest, hvec, 2);
1172   gcry_free (rawmpi); rawmpi = NULL;
1173   if (rc)
1174     goto leave;
1175
1176   /* Compute the A value (this modifies DIGEST).  */
1177   reverse_buffer (digest, 32);  /* Only the first half of the hash.  */
1178   digest[0] = (digest[0] & 0x7f) | 0x40;
1179   digest[31] &= 0xf8;
1180   _gcry_mpi_set_buffer (a, digest, 32, 0);
1181
1182   /* Compute the public key if it has not been supplied as optional
1183      parameter.  */
1184   if (pk)
1185     {
1186       rc = _gcry_ecc_eddsa_decodepoint (pk, ctx, &Q,  &encpk, &encpklen);
1187       if (rc)
1188         goto leave;
1189       if (DBG_CIPHER)
1190         log_printhex ("* e_pk", encpk, encpklen);
1191       if (!_gcry_mpi_ec_curve_point (&Q, ctx))
1192         {
1193           rc = GPG_ERR_BROKEN_PUBKEY;
1194           goto leave;
1195         }
1196     }
1197   else
1198     {
1199       _gcry_mpi_ec_mul_point (&Q, a, &skey->E.G, ctx);
1200       rc = _gcry_ecc_eddsa_encodepoint (&Q, ctx, x, y, &encpk, &encpklen);
1201       if (rc)
1202         goto leave;
1203       if (DBG_CIPHER)
1204         log_printhex ("  e_pk", encpk, encpklen);
1205     }
1206
1207   /* Compute R.  */
1208   mbuf = gcry_mpi_get_opaque (input, &tmp);
1209   mlen = (tmp +7)/8;
1210   if (DBG_CIPHER)
1211     log_printhex ("     m", mbuf, mlen);
1212
1213   hvec[0].data = digest;
1214   hvec[0].off  = 32;
1215   hvec[0].len  = 32;
1216   hvec[1].data = (char*)mbuf;
1217   hvec[1].len  = mlen;
1218   rc = _gcry_md_hash_buffers (hashalgo, 0, digest, hvec, 2);
1219   if (rc)
1220     goto leave;
1221   reverse_buffer (digest, 64);
1222   if (DBG_CIPHER)
1223     log_printhex ("     r", digest, 64);
1224   _gcry_mpi_set_buffer (r, digest, 64, 0);
1225   _gcry_mpi_ec_mul_point (&I, r, &skey->E.G, ctx);
1226   if (DBG_CIPHER)
1227     log_printpnt ("   r", &I, ctx);
1228
1229   /* Convert R into affine coordinates and apply encoding.  */
1230   rc = _gcry_ecc_eddsa_encodepoint (&I, ctx, x, y, &rawmpi, &rawmpilen);
1231   if (rc)
1232     goto leave;
1233   if (DBG_CIPHER)
1234     log_printhex ("   e_r", rawmpi, rawmpilen);
1235
1236   /* S = r + a * H(encodepoint(R) + encodepoint(pk) + m) mod n  */
1237   hvec[0].data = rawmpi;  /* (this is R) */
1238   hvec[0].off  = 0;
1239   hvec[0].len  = rawmpilen;
1240   hvec[1].data = encpk;
1241   hvec[1].off  = 0;
1242   hvec[1].len  = encpklen;
1243   hvec[2].data = (char*)mbuf;
1244   hvec[2].off  = 0;
1245   hvec[2].len  = mlen;
1246   rc = _gcry_md_hash_buffers (hashalgo, 0, digest, hvec, 3);
1247   if (rc)
1248     goto leave;
1249
1250   /* No more need for RAWMPI thus we now transfer it to R_R.  */
1251   gcry_mpi_set_opaque (r_r, rawmpi, rawmpilen*8);
1252   rawmpi = NULL;
1253
1254   reverse_buffer (digest, 64);
1255   if (DBG_CIPHER)
1256     log_printhex (" H(R+)", digest, 64);
1257   _gcry_mpi_set_buffer (s, digest, 64, 0);
1258   mpi_mulm (s, s, a, skey->E.n);
1259   mpi_addm (s, s, r, skey->E.n);
1260   rc = eddsa_encodempi (s, b, &rawmpi, &rawmpilen);
1261   if (rc)
1262     goto leave;
1263   if (DBG_CIPHER)
1264     log_printhex ("   e_s", rawmpi, rawmpilen);
1265   gcry_mpi_set_opaque (s, rawmpi, rawmpilen*8);
1266   rawmpi = NULL;
1267
1268   rc = 0;
1269
1270  leave:
1271   gcry_mpi_release (a);
1272   gcry_mpi_release (x);
1273   gcry_mpi_release (y);
1274   gcry_mpi_release (r);
1275   gcry_free (digest);
1276   _gcry_mpi_ec_free (ctx);
1277   point_free (&I);
1278   point_free (&Q);
1279   gcry_free (encpk);
1280   gcry_free (rawmpi);
1281   return rc;
1282 }
1283
1284
1285 /* Verify an EdDSA signature.  See sign_eddsa for the reference.
1286  * Check if R_IN and S_IN verifies INPUT.  PKEY has the curve
1287  * parameters and PK is the EdDSA style encoded public key.
1288  */
1289 static gpg_err_code_t
1290 verify_eddsa (gcry_mpi_t input, ECC_public_key *pkey,
1291               gcry_mpi_t r_in, gcry_mpi_t s_in, int hashalgo, gcry_mpi_t pk)
1292 {
1293   int rc;
1294   mpi_ec_t ctx = NULL;
1295   int b;
1296   unsigned int tmp;
1297   mpi_point_struct Q;          /* Public key.  */
1298   unsigned char *encpk = NULL; /* Encoded public key.  */
1299   unsigned int encpklen;
1300   const void *mbuf, *rbuf;
1301   unsigned char *tbuf = NULL;
1302   size_t mlen, rlen;
1303   unsigned int tlen;
1304   unsigned char digest[64];
1305   gcry_buffer_t hvec[3];
1306   gcry_mpi_t h, s;
1307   mpi_point_struct Ia, Ib;
1308
1309   if (!mpi_is_opaque (input) || !mpi_is_opaque (r_in) || !mpi_is_opaque (s_in))
1310     return GPG_ERR_INV_DATA;
1311   if (hashalgo != GCRY_MD_SHA512)
1312     return GPG_ERR_DIGEST_ALGO;
1313
1314   point_init (&Q);
1315   point_init (&Ia);
1316   point_init (&Ib);
1317   h = mpi_new (0);
1318   s = mpi_new (0);
1319
1320   ctx = _gcry_mpi_ec_p_internal_new (pkey->E.model, pkey->E.dialect,
1321                                      pkey->E.p, pkey->E.a, pkey->E.b);
1322   b = ctx->nbits/8;
1323   if (b != 256/8)
1324     return GPG_ERR_INTERNAL; /* We only support 256 bit. */
1325
1326   /* Decode and check the public key.  */
1327   rc = _gcry_ecc_eddsa_decodepoint (pk, ctx, &Q, &encpk, &encpklen);
1328   if (rc)
1329     goto leave;
1330   if (!_gcry_mpi_ec_curve_point (&Q, ctx))
1331     {
1332       rc = GPG_ERR_BROKEN_PUBKEY;
1333       goto leave;
1334     }
1335   if (DBG_CIPHER)
1336     log_printhex ("  e_pk", encpk, encpklen);
1337   if (encpklen != b)
1338     {
1339       rc = GPG_ERR_INV_LENGTH;
1340       goto leave;
1341     }
1342
1343   /* Convert the other input parameters.  */
1344   mbuf = gcry_mpi_get_opaque (input, &tmp);
1345   mlen = (tmp +7)/8;
1346   if (DBG_CIPHER)
1347     log_printhex ("     m", mbuf, mlen);
1348   rbuf = gcry_mpi_get_opaque (r_in, &tmp);
1349   rlen = (tmp +7)/8;
1350   if (DBG_CIPHER)
1351     log_printhex ("     r", rbuf, rlen);
1352   if (rlen != b)
1353     {
1354       rc = GPG_ERR_INV_LENGTH;
1355       goto leave;
1356     }
1357
1358   /* h = H(encodepoint(R) + encodepoint(pk) + m)  */
1359   hvec[0].data = (char*)rbuf;
1360   hvec[0].off  = 0;
1361   hvec[0].len  = rlen;
1362   hvec[1].data = encpk;
1363   hvec[1].off  = 0;
1364   hvec[1].len  = encpklen;
1365   hvec[2].data = (char*)mbuf;
1366   hvec[2].off  = 0;
1367   hvec[2].len  = mlen;
1368   rc = _gcry_md_hash_buffers (hashalgo, 0, digest, hvec, 3);
1369   if (rc)
1370     goto leave;
1371   reverse_buffer (digest, 64);
1372   if (DBG_CIPHER)
1373     log_printhex (" H(R+)", digest, 64);
1374   _gcry_mpi_set_buffer (h, digest, 64, 0);
1375
1376   /* According to the paper the best way for verification is:
1377          encodepoint(sG - h·Q) = encodepoint(r)
1378      because we don't need to decode R. */
1379   {
1380     void *sbuf;
1381     unsigned int slen;
1382
1383     sbuf = _gcry_mpi_get_opaque_copy (s_in, &tmp);
1384     slen = (tmp +7)/8;
1385     reverse_buffer (sbuf, slen);
1386     if (DBG_CIPHER)
1387       log_printhex ("     s", sbuf, slen);
1388     _gcry_mpi_set_buffer (s, sbuf, slen, 0);
1389     gcry_free (sbuf);
1390     if (slen != b)
1391       {
1392         rc = GPG_ERR_INV_LENGTH;
1393         goto leave;
1394       }
1395   }
1396
1397   _gcry_mpi_ec_mul_point (&Ia, s, &pkey->E.G, ctx);
1398   _gcry_mpi_ec_mul_point (&Ib, h, &Q, ctx);
1399   _gcry_mpi_neg (Ib.x, Ib.x);
1400   _gcry_mpi_ec_add_points (&Ia, &Ia, &Ib, ctx);
1401   rc = _gcry_ecc_eddsa_encodepoint (&Ia, ctx, s, h, &tbuf, &tlen);
1402   if (rc)
1403     goto leave;
1404   if (tlen != rlen || memcmp (tbuf, rbuf, tlen))
1405     {
1406       rc = GPG_ERR_BAD_SIGNATURE;
1407       goto leave;
1408     }
1409
1410   rc = 0;
1411
1412  leave:
1413   gcry_free (encpk);
1414   gcry_free (tbuf);
1415   _gcry_mpi_ec_free (ctx);
1416   gcry_mpi_release (s);
1417   gcry_mpi_release (h);
1418   point_free (&Ia);
1419   point_free (&Ib);
1420   point_free (&Q);
1421   return rc;
1422 }
1423
1424
1425 \f
1426 /*********************************************
1427  **************  interface  ******************
1428  *********************************************/
1429
1430 static gcry_err_code_t
1431 ecc_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
1432 {
1433   gpg_err_code_t rc;
1434   unsigned int nbits;
1435   elliptic_curve_t E;
1436   ECC_secret_key sk;
1437   gcry_mpi_t x = NULL;
1438   gcry_mpi_t y = NULL;
1439   char *curve_name = NULL;
1440   gcry_sexp_t l1;
1441   gcry_random_level_t random_level;
1442   mpi_ec_t ctx = NULL;
1443   gcry_sexp_t curve_info = NULL;
1444   gcry_sexp_t curve_flags = NULL;
1445   gcry_mpi_t base = NULL;
1446   gcry_mpi_t public = NULL;
1447   gcry_mpi_t secret = NULL;
1448   int flags = 0;
1449   int ed25519_with_ecdsa = 0;
1450
1451   memset (&E, 0, sizeof E);
1452   memset (&sk, 0, sizeof sk);
1453
1454   rc = _gcry_pk_util_get_nbits (genparms, &nbits);
1455   if (rc)
1456     return rc;
1457
1458   /* Parse the optional "curve" parameter. */
1459   l1 = gcry_sexp_find_token (genparms, "curve", 0);
1460   if (l1)
1461     {
1462       curve_name = _gcry_sexp_nth_string (l1, 1);
1463       gcry_sexp_release (l1);
1464       if (!curve_name)
1465         return GPG_ERR_INV_OBJ; /* No curve name or value too large. */
1466     }
1467
1468   /* Parse the optional transient-key flag.  */
1469   l1 = gcry_sexp_find_token (genparms, "transient-key", 0);
1470   if (l1)
1471     {
1472       flags |= PUBKEY_FLAG_TRANSIENT_KEY;
1473       gcry_sexp_release (l1);
1474     }
1475
1476   /* Parse the optional flags list.  */
1477   l1 = gcry_sexp_find_token (genparms, "flags", 0);
1478   if (l1)
1479     {
1480       rc = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
1481       gcry_sexp_release (l1);
1482       if (rc)
1483         goto leave;
1484     }
1485
1486   /* NBITS is required if no curve name has been given.  */
1487   if (!nbits && !curve_name)
1488     return GPG_ERR_NO_OBJ; /* No NBITS parameter. */
1489
1490   rc = _gcry_ecc_fill_in_curve (nbits, curve_name, &E, &nbits);
1491   gcry_free (curve_name); curve_name = NULL;
1492   if (rc)
1493     goto leave;
1494
1495   if (DBG_CIPHER)
1496     {
1497       log_debug ("ecgen curve info: %s/%s\n",
1498                  _gcry_ecc_model2str (E.model),
1499                  _gcry_ecc_dialect2str (E.dialect));
1500       if (E.name)
1501         log_debug ("ecgen curve used: %s\n", E.name);
1502       log_printmpi ("ecgen curve   p", E.p);
1503       log_printmpi ("ecgen curve   a", E.a);
1504       log_printmpi ("ecgen curve   b", E.b);
1505       log_printmpi ("ecgen curve   n", E.n);
1506       log_printpnt ("ecgen curve G", &E.G, NULL);
1507     }
1508
1509   if ((flags & PUBKEY_FLAG_TRANSIENT_KEY))
1510     random_level = GCRY_STRONG_RANDOM;
1511   else
1512     random_level = GCRY_VERY_STRONG_RANDOM;
1513
1514   ctx = _gcry_mpi_ec_p_internal_new (E.model, E.dialect, E.p, E.a, E.b);
1515   x = mpi_new (0);
1516   y = mpi_new (0);
1517
1518   switch (E.dialect)
1519     {
1520     case ECC_DIALECT_STANDARD:
1521       rc = nist_generate_key (&sk, &E, ctx, random_level, nbits);
1522       break;
1523     case ECC_DIALECT_ED25519:
1524       if ((flags & PUBKEY_FLAG_ECDSA))
1525         {
1526           ed25519_with_ecdsa = 1;
1527           rc = nist_generate_key (&sk, &E, ctx, random_level, nbits);
1528         }
1529       else
1530         rc = eddsa_generate_key (&sk, &E, ctx, random_level);
1531       break;
1532     default:
1533       rc = GPG_ERR_INTERNAL;
1534       break;
1535     }
1536   if (rc)
1537     goto leave;
1538
1539   /* Copy data to the result.  */
1540   if (_gcry_mpi_ec_get_affine (x, y, &sk.E.G, ctx))
1541     log_fatal ("ecgen: Failed to get affine coordinates for %s\n", "G");
1542   base = _gcry_ecc_ec2os (x, y, sk.E.p);
1543   if (sk.E.dialect == ECC_DIALECT_ED25519 && !ed25519_with_ecdsa)
1544     {
1545       unsigned char *encpk;
1546       unsigned int encpklen;
1547
1548       rc = _gcry_ecc_eddsa_encodepoint (&sk.Q, ctx, x, y, &encpk, &encpklen);
1549       if (rc)
1550         return rc;
1551       public = mpi_new (0);
1552       gcry_mpi_set_opaque (public, encpk, encpklen*8);
1553       encpk = NULL;
1554     }
1555   else
1556     {
1557       if (_gcry_mpi_ec_get_affine (x, y, &sk.Q, ctx))
1558         log_fatal ("ecgen: Failed to get affine coordinates for %s\n", "Q");
1559       public = _gcry_ecc_ec2os (x, y, sk.E.p);
1560     }
1561   secret = sk.d; sk.d = NULL;
1562   if (E.name)
1563     {
1564       rc = gcry_sexp_build (&curve_info, NULL, "(curve %s)", E.name);
1565       if (rc)
1566         goto leave;
1567     }
1568
1569   if (ed25519_with_ecdsa)
1570     {
1571       rc = gcry_sexp_build (&curve_flags, NULL, "(flags ecdsa)");
1572       if (rc)
1573         goto leave;
1574     }
1575
1576   rc = gcry_sexp_build (r_skey, NULL,
1577                         "(key-data"
1578                         " (public-key"
1579                         "  (ecc%S%S(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))"
1580                         " (private-key"
1581                         "  (ecc%S%S(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))"
1582                         " )",
1583                         curve_info, curve_flags,
1584                         sk.E.p, sk.E.a, sk.E.b, base, sk.E.n, public,
1585                         curve_info, curve_flags,
1586                         sk.E.p, sk.E.a, sk.E.b, base, sk.E.n, public, secret);
1587   if (rc)
1588     goto leave;
1589
1590   if (DBG_CIPHER)
1591     {
1592       log_printmpi ("ecgen result  p", sk.E.p);
1593       log_printmpi ("ecgen result  a", sk.E.a);
1594       log_printmpi ("ecgen result  b", sk.E.b);
1595       log_printmpi ("ecgen result  G", base);
1596       log_printmpi ("ecgen result  n", sk.E.n);
1597       log_printmpi ("ecgen result  Q", public);
1598       log_printmpi ("ecgen result  d", secret);
1599       if (ed25519_with_ecdsa)
1600         log_debug ("ecgen result  using Ed25519/ECDSA\n");
1601     }
1602
1603  leave:
1604   mpi_free (secret);
1605   mpi_free (public);
1606   mpi_free (base);
1607   {
1608     _gcry_ecc_curve_free (&sk.E);
1609     point_free (&sk.Q);
1610     mpi_free (sk.d);
1611   }
1612   _gcry_ecc_curve_free (&E);
1613   mpi_free (x);
1614   mpi_free (y);
1615   _gcry_mpi_ec_free (ctx);
1616   gcry_sexp_release (curve_flags);
1617   gcry_sexp_release (curve_info);
1618   return rc;
1619 }
1620
1621
1622 static gcry_err_code_t
1623 ecc_check_secret_key (gcry_sexp_t keyparms)
1624 {
1625   gcry_err_code_t rc;
1626   gcry_sexp_t l1 = NULL;
1627   char *curvename = NULL;
1628   gcry_mpi_t mpi_g = NULL;
1629   gcry_mpi_t mpi_q = NULL;
1630   ECC_secret_key sk;
1631
1632   memset (&sk, 0, sizeof sk);
1633
1634   /*
1635    * Extract the key.
1636    */
1637   rc = _gcry_sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?/q?+d",
1638                                  &sk.E.p, &sk.E.a, &sk.E.b, &mpi_g, &sk.E.n,
1639                                  &mpi_q, &sk.d, NULL);
1640   if (rc)
1641     goto leave;
1642   if (mpi_g)
1643     {
1644       point_init (&sk.E.G);
1645       rc = _gcry_ecc_os2ec (&sk.E.G, mpi_g);
1646       if (rc)
1647         goto leave;
1648     }
1649   /* Add missing parameters using the optional curve parameter.  */
1650   gcry_sexp_release (l1);
1651   l1 = gcry_sexp_find_token (keyparms, "curve", 5);
1652   if (l1)
1653     {
1654       curvename = gcry_sexp_nth_string (l1, 1);
1655       if (curvename)
1656         {
1657           rc = _gcry_ecc_fill_in_curve (0, curvename, &sk.E, NULL);
1658           if (rc)
1659             return rc;
1660         }
1661     }
1662   /* Guess required fields if a curve parameter has not been given.
1663      FIXME: This is a crude hacks.  We need to fix that.  */
1664   if (!curvename)
1665     {
1666       sk.E.model = MPI_EC_WEIERSTRASS;
1667       sk.E.dialect = ECC_DIALECT_STANDARD;
1668     }
1669   if (DBG_CIPHER)
1670     {
1671       log_debug ("ecc_testkey inf: %s/%s\n",
1672                  _gcry_ecc_model2str (sk.E.model),
1673                  _gcry_ecc_dialect2str (sk.E.dialect));
1674       if (sk.E.name)
1675         log_debug  ("ecc_testkey nam: %s\n", sk.E.name);
1676       log_printmpi ("ecc_testkey   p", sk.E.p);
1677       log_printmpi ("ecc_testkey   a", sk.E.a);
1678       log_printmpi ("ecc_testkey   b", sk.E.b);
1679       log_printpnt ("ecc_testkey g",   &sk.E.G, NULL);
1680       log_printmpi ("ecc_testkey   n", sk.E.n);
1681       log_printmpi ("ecc_testkey   q", mpi_q);
1682       if (!fips_mode ())
1683         log_printmpi ("ecc_testkey   d", sk.d);
1684     }
1685   if (!sk.E.p || !sk.E.a || !sk.E.b || !sk.E.G.x || !sk.E.n || !sk.d)
1686     {
1687       rc = GPG_ERR_NO_OBJ;
1688       goto leave;
1689     }
1690
1691   if (mpi_q)
1692     {
1693       point_init (&sk.Q);
1694       rc = _gcry_ecc_os2ec (&sk.Q, mpi_q);
1695       if (rc)
1696         goto leave;
1697     }
1698   else
1699     {
1700       /* The current test requires Q.  */
1701       rc = GPG_ERR_NO_OBJ;
1702       goto leave;
1703     }
1704
1705   if (check_secret_key (&sk))
1706     rc = GPG_ERR_BAD_SECKEY;
1707
1708  leave:
1709   gcry_mpi_release (sk.E.p);
1710   gcry_mpi_release (sk.E.a);
1711   gcry_mpi_release (sk.E.b);
1712   gcry_mpi_release (mpi_g);
1713   point_free (&sk.E.G);
1714   gcry_mpi_release (sk.E.n);
1715   gcry_mpi_release (mpi_q);
1716   point_free (&sk.Q);
1717   gcry_mpi_release (sk.d);
1718   gcry_free (curvename);
1719   gcry_sexp_release (l1);
1720   if (DBG_CIPHER)
1721     log_debug ("ecc_testkey   => %s\n", gpg_strerror (rc));
1722   return rc;
1723 }
1724
1725
1726 static gcry_err_code_t
1727 ecc_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
1728 {
1729   gcry_err_code_t rc;
1730   struct pk_encoding_ctx ctx;
1731   gcry_mpi_t data = NULL;
1732   gcry_sexp_t l1 = NULL;
1733   char *curvename = NULL;
1734   gcry_mpi_t mpi_g = NULL;
1735   gcry_mpi_t mpi_q = NULL;
1736   ECC_secret_key sk;
1737   gcry_mpi_t sig_r = NULL;
1738   gcry_mpi_t sig_s = NULL;
1739
1740   memset (&sk, 0, sizeof sk);
1741
1742   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_SIGN, 0);
1743
1744   /* Extract the data.  */
1745   rc = _gcry_pk_util_data_to_mpi (s_data, &data, &ctx);
1746   if (rc)
1747     goto leave;
1748   if (DBG_CIPHER)
1749     log_mpidump ("ecc_sign   data", data);
1750
1751   /*
1752    * Extract the key.
1753    */
1754   rc = _gcry_sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?/q?+d",
1755                                  &sk.E.p, &sk.E.a, &sk.E.b, &mpi_g, &sk.E.n,
1756                                  &mpi_q, &sk.d, NULL);
1757   if (rc)
1758     goto leave;
1759   if (mpi_g)
1760     {
1761       point_init (&sk.E.G);
1762       rc = _gcry_ecc_os2ec (&sk.E.G, mpi_g);
1763       if (rc)
1764         goto leave;
1765     }
1766   /* Add missing parameters using the optional curve parameter.  */
1767   gcry_sexp_release (l1);
1768   l1 = gcry_sexp_find_token (keyparms, "curve", 5);
1769   if (l1)
1770     {
1771       curvename = gcry_sexp_nth_string (l1, 1);
1772       if (curvename)
1773         {
1774           rc = _gcry_ecc_fill_in_curve (0, curvename, &sk.E, NULL);
1775           if (rc)
1776             return rc;
1777         }
1778     }
1779   /* Guess required fields if a curve parameter has not been given.
1780      FIXME: This is a crude hacks.  We need to fix that.  */
1781   if (!curvename)
1782     {
1783       sk.E.model = ((ctx.flags & PUBKEY_FLAG_EDDSA)
1784                     ? MPI_EC_TWISTEDEDWARDS
1785                     : MPI_EC_WEIERSTRASS);
1786       sk.E.dialect = ((ctx.flags & PUBKEY_FLAG_EDDSA)
1787                       ? ECC_DIALECT_ED25519
1788                       : ECC_DIALECT_STANDARD);
1789     }
1790   if (DBG_CIPHER)
1791     {
1792       log_debug ("ecc_sign   info: %s/%s%s\n",
1793                  _gcry_ecc_model2str (sk.E.model),
1794                  _gcry_ecc_dialect2str (sk.E.dialect),
1795                  (sk.E.dialect == ECC_DIALECT_ED25519
1796                   && (ctx.flags & PUBKEY_FLAG_ECDSA))? "ECDSA":"");
1797       if (sk.E.name)
1798         log_debug  ("ecc_sign   name: %s\n", sk.E.name);
1799       log_printmpi ("ecc_sign      p", sk.E.p);
1800       log_printmpi ("ecc_sign      a", sk.E.a);
1801       log_printmpi ("ecc_sign      b", sk.E.b);
1802       log_printpnt ("ecc_sign    g",   &sk.E.G, NULL);
1803       log_printmpi ("ecc_sign      n", sk.E.n);
1804       log_printmpi ("ecc_sign      q", mpi_q);
1805       if (!fips_mode ())
1806         log_printmpi ("ecc_sign      d", sk.d);
1807     }
1808   if (!sk.E.p || !sk.E.a || !sk.E.b || !sk.E.G.x || !sk.E.n || !sk.d)
1809     {
1810       rc = GPG_ERR_NO_OBJ;
1811       goto leave;
1812     }
1813
1814
1815   sig_r = gcry_mpi_new (0);
1816   sig_s = gcry_mpi_new (0);
1817   if ((ctx.flags & PUBKEY_FLAG_EDDSA))
1818     {
1819       /* EdDSA requires the public key.  */
1820       rc = sign_eddsa (data, &sk, sig_r, sig_s, ctx.hash_algo, mpi_q);
1821       if (!rc)
1822         rc = gcry_sexp_build (r_sig, NULL,
1823                               "(sig-val(eddsa(r%M)(s%M)))", sig_r, sig_s);
1824     }
1825   else if ((ctx.flags & PUBKEY_FLAG_GOST))
1826     {
1827       rc = sign_gost (data, &sk, sig_r, sig_s);
1828       if (!rc)
1829         rc = gcry_sexp_build (r_sig, NULL,
1830                               "(sig-val(gost(r%M)(s%M)))", sig_r, sig_s);
1831     }
1832   else
1833     {
1834       rc = sign_ecdsa (data, &sk, sig_r, sig_s, ctx.flags, ctx.hash_algo);
1835       if (!rc)
1836         rc = gcry_sexp_build (r_sig, NULL,
1837                               "(sig-val(ecdsa(r%M)(s%M)))", sig_r, sig_s);
1838     }
1839
1840
1841  leave:
1842   gcry_mpi_release (sk.E.p);
1843   gcry_mpi_release (sk.E.a);
1844   gcry_mpi_release (sk.E.b);
1845   gcry_mpi_release (mpi_g);
1846   point_free (&sk.E.G);
1847   gcry_mpi_release (sk.E.n);
1848   gcry_mpi_release (mpi_q);
1849   point_free (&sk.Q);
1850   gcry_mpi_release (sk.d);
1851   gcry_mpi_release (sig_r);
1852   gcry_mpi_release (sig_s);
1853   gcry_free (curvename);
1854   gcry_mpi_release (data);
1855   gcry_sexp_release (l1);
1856   _gcry_pk_util_free_encoding_ctx (&ctx);
1857   if (DBG_CIPHER)
1858     log_debug ("ecc_sign      => %s\n", gpg_strerror (rc));
1859   return rc;
1860 }
1861
1862
1863 static gcry_err_code_t
1864 ecc_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t s_keyparms)
1865 {
1866   gcry_err_code_t rc;
1867   struct pk_encoding_ctx ctx;
1868   gcry_sexp_t l1 = NULL;
1869   char *curvename = NULL;
1870   gcry_mpi_t mpi_g = NULL;
1871   gcry_mpi_t mpi_q = NULL;
1872   gcry_mpi_t sig_r = NULL;
1873   gcry_mpi_t sig_s = NULL;
1874   gcry_mpi_t data = NULL;
1875   ECC_public_key pk;
1876   int sigflags;
1877
1878   memset (&pk, 0, sizeof pk);
1879   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_VERIFY,
1880                                    ecc_get_nbits (s_keyparms));
1881
1882   /* Extract the data.  */
1883   rc = _gcry_pk_util_data_to_mpi (s_data, &data, &ctx);
1884   if (rc)
1885     goto leave;
1886   if (DBG_CIPHER)
1887     log_mpidump ("ecc_verify data", data);
1888
1889   /*
1890    * Extract the signature value.
1891    */
1892   rc = _gcry_pk_util_preparse_sigval (s_sig, ecc_names, &l1, &sigflags);
1893   if (rc)
1894     goto leave;
1895   rc = _gcry_sexp_extract_param (l1, NULL,
1896                                  (sigflags & PUBKEY_FLAG_EDDSA)? "/rs":"rs",
1897                                  &sig_r, &sig_s, NULL);
1898   if (rc)
1899     goto leave;
1900   if (DBG_CIPHER)
1901     {
1902       log_mpidump ("ecc_verify  s_r", sig_r);
1903       log_mpidump ("ecc_verify  s_s", sig_s);
1904     }
1905   if ((ctx.flags & PUBKEY_FLAG_EDDSA) ^ (sigflags & PUBKEY_FLAG_EDDSA))
1906     {
1907       rc = GPG_ERR_CONFLICT; /* Inconsistent use of flag/algoname.  */
1908       goto leave;
1909     }
1910
1911
1912   /*
1913    * Extract the key.
1914    */
1915   rc = _gcry_sexp_extract_param (s_keyparms, NULL, "-p?a?b?g?n?/q?",
1916                                  &pk.E.p, &pk.E.a, &pk.E.b, &mpi_g, &pk.E.n,
1917                                  &mpi_q, NULL);
1918   if (rc)
1919     goto leave;
1920   if (mpi_g)
1921     {
1922       point_init (&pk.E.G);
1923       rc = _gcry_ecc_os2ec (&pk.E.G, mpi_g);
1924       if (rc)
1925         goto leave;
1926     }
1927   /* Add missing parameters using the optional curve parameter.  */
1928   gcry_sexp_release (l1);
1929   l1 = gcry_sexp_find_token (s_keyparms, "curve", 5);
1930   if (l1)
1931     {
1932       curvename = gcry_sexp_nth_string (l1, 1);
1933       if (curvename)
1934         {
1935           rc = _gcry_ecc_fill_in_curve (0, curvename, &pk.E, NULL);
1936           if (rc)
1937             return rc;
1938         }
1939     }
1940   /* Guess required fields if a curve parameter has not been given.
1941      FIXME: This is a crude hacks.  We need to fix that.  */
1942   if (!curvename)
1943     {
1944       pk.E.model = ((sigflags & PUBKEY_FLAG_EDDSA)
1945                     ? MPI_EC_TWISTEDEDWARDS
1946                     : MPI_EC_WEIERSTRASS);
1947       pk.E.dialect = ((sigflags & PUBKEY_FLAG_EDDSA)
1948                       ? ECC_DIALECT_ED25519
1949                       : ECC_DIALECT_STANDARD);
1950     }
1951
1952   if (DBG_CIPHER)
1953     {
1954       log_debug ("ecc_verify info: %s/%s%s\n",
1955                  _gcry_ecc_model2str (pk.E.model),
1956                  _gcry_ecc_dialect2str (pk.E.dialect),
1957                  (pk.E.dialect == ECC_DIALECT_ED25519
1958                   && !(sigflags & PUBKEY_FLAG_EDDSA))? "/ECDSA":"");
1959       if (pk.E.name)
1960         log_debug  ("ecc_verify name: %s\n", pk.E.name);
1961       log_printmpi ("ecc_verify    p", pk.E.p);
1962       log_printmpi ("ecc_verify    a", pk.E.a);
1963       log_printmpi ("ecc_verify    b", pk.E.b);
1964       log_printpnt ("ecc_verify  g",   &pk.E.G, NULL);
1965       log_printmpi ("ecc_verify    n", pk.E.n);
1966       log_printmpi ("ecc_verify    q", mpi_q);
1967     }
1968   if (!pk.E.p || !pk.E.a || !pk.E.b || !pk.E.G.x || !pk.E.n || !mpi_q)
1969     {
1970       rc = GPG_ERR_NO_OBJ;
1971       goto leave;
1972     }
1973
1974
1975   /*
1976    * Verify the signature.
1977    */
1978   if ((sigflags & PUBKEY_FLAG_EDDSA))
1979     {
1980       rc = verify_eddsa (data, &pk, sig_r, sig_s, ctx.hash_algo, mpi_q);
1981     }
1982   else if ((sigflags & PUBKEY_FLAG_GOST))
1983     {
1984       point_init (&pk.Q);
1985       rc = _gcry_ecc_os2ec (&pk.Q, mpi_q);
1986       if (rc)
1987         goto leave;
1988
1989       rc = verify_gost (data, &pk, sig_r, sig_s);
1990     }
1991   else
1992     {
1993       point_init (&pk.Q);
1994       rc = _gcry_ecc_os2ec (&pk.Q, mpi_q);
1995       if (rc)
1996         goto leave;
1997
1998       if (mpi_is_opaque (data))
1999         {
2000           const void *abuf;
2001           unsigned int abits, qbits;
2002           gcry_mpi_t a;
2003
2004           qbits = mpi_get_nbits (pk.E.n);
2005
2006           abuf = gcry_mpi_get_opaque (data, &abits);
2007           rc = gpg_err_code (gcry_mpi_scan (&a, GCRYMPI_FMT_USG,
2008                                             abuf, (abits+7)/8, NULL));
2009           if (!rc)
2010             {
2011               if (abits > qbits)
2012                 gcry_mpi_rshift (a, a, abits - qbits);
2013
2014               rc = verify_ecdsa (a, &pk, sig_r, sig_s);
2015               gcry_mpi_release (a);
2016             }
2017         }
2018       else
2019         rc = verify_ecdsa (data, &pk, sig_r, sig_s);
2020     }
2021
2022  leave:
2023   gcry_mpi_release (pk.E.p);
2024   gcry_mpi_release (pk.E.a);
2025   gcry_mpi_release (pk.E.b);
2026   gcry_mpi_release (mpi_g);
2027   point_free (&pk.E.G);
2028   gcry_mpi_release (pk.E.n);
2029   gcry_mpi_release (mpi_q);
2030   point_free (&pk.Q);
2031   gcry_mpi_release (data);
2032   gcry_mpi_release (sig_r);
2033   gcry_mpi_release (sig_s);
2034   gcry_free (curvename);
2035   gcry_sexp_release (l1);
2036   _gcry_pk_util_free_encoding_ctx (&ctx);
2037   if (DBG_CIPHER)
2038     log_debug ("ecc_verify    => %s\n", rc?gpg_strerror (rc):"Good");
2039   return rc;
2040 }
2041
2042
2043 /* ecdh raw is classic 2-round DH protocol published in 1976.
2044  *
2045  * Overview of ecc_encrypt_raw and ecc_decrypt_raw.
2046  *
2047  * As with any PK operation, encrypt version uses a public key and
2048  * decrypt -- private.
2049  *
2050  * Symbols used below:
2051  *     G - field generator point
2052  *     d - private long-term scalar
2053  *    dG - public long-term key
2054  *     k - ephemeral scalar
2055  *    kG - ephemeral public key
2056  *   dkG - shared secret
2057  *
2058  * ecc_encrypt_raw description:
2059  *   input:
2060  *     data[0] : private scalar (k)
2061  *   output: A new S-expression with the parameters:
2062  *     s : shared point (kdG)
2063  *     e : generated ephemeral public key (kG)
2064  *
2065  * ecc_decrypt_raw description:
2066  *   input:
2067  *     data[0] : a point kG (ephemeral public key)
2068  *   output:
2069  *     result[0] : shared point (kdG)
2070  */
2071 static gcry_err_code_t
2072 ecc_encrypt_raw (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t keyparms)
2073 {
2074   gcry_err_code_t rc;
2075   struct pk_encoding_ctx ctx;
2076   gcry_sexp_t l1 = NULL;
2077   char *curvename = NULL;
2078   gcry_mpi_t mpi_g = NULL;
2079   gcry_mpi_t mpi_q = NULL;
2080   gcry_mpi_t mpi_s = NULL;
2081   gcry_mpi_t mpi_e = NULL;
2082   gcry_mpi_t data = NULL;
2083   ECC_public_key pk;
2084   mpi_ec_t ec = NULL;
2085
2086   memset (&pk, 0, sizeof pk);
2087   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_ENCRYPT,
2088                                    ecc_get_nbits (keyparms));
2089
2090   /*
2091    * Extract the data.
2092    */
2093   rc = _gcry_pk_util_data_to_mpi (s_data, &data, &ctx);
2094   if (rc)
2095     goto leave;
2096   if (DBG_CIPHER)
2097     log_mpidump ("ecc_encrypt data", data);
2098   if (mpi_is_opaque (data))
2099     {
2100       rc = GPG_ERR_INV_DATA;
2101       goto leave;
2102     }
2103
2104
2105   /*
2106    * Extract the key.
2107    */
2108   rc = _gcry_sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?+q",
2109                                  &pk.E.p, &pk.E.a, &pk.E.b, &mpi_g, &pk.E.n,
2110                                  &mpi_q, NULL);
2111   if (rc)
2112     goto leave;
2113   if (mpi_g)
2114     {
2115       point_init (&pk.E.G);
2116       rc = _gcry_ecc_os2ec (&pk.E.G, mpi_g);
2117       if (rc)
2118         goto leave;
2119     }
2120   /* Add missing parameters using the optional curve parameter.  */
2121   gcry_sexp_release (l1);
2122   l1 = gcry_sexp_find_token (keyparms, "curve", 5);
2123   if (l1)
2124     {
2125       curvename = gcry_sexp_nth_string (l1, 1);
2126       if (curvename)
2127         {
2128           rc = _gcry_ecc_fill_in_curve (0, curvename, &pk.E, NULL);
2129           if (rc)
2130             return rc;
2131         }
2132     }
2133   /* Guess required fields if a curve parameter has not been given.  */
2134   if (!curvename)
2135     {
2136       pk.E.model = MPI_EC_WEIERSTRASS;
2137       pk.E.dialect = ECC_DIALECT_STANDARD;
2138     }
2139
2140   if (DBG_CIPHER)
2141     {
2142       log_debug ("ecc_encrypt info: %s/%s\n",
2143                  _gcry_ecc_model2str (pk.E.model),
2144                  _gcry_ecc_dialect2str (pk.E.dialect));
2145       if (pk.E.name)
2146         log_debug  ("ecc_encrypt name: %s\n", pk.E.name);
2147       log_printmpi ("ecc_encrypt    p", pk.E.p);
2148       log_printmpi ("ecc_encrypt    a", pk.E.a);
2149       log_printmpi ("ecc_encrypt    b", pk.E.b);
2150       log_printpnt ("ecc_encrypt  g",   &pk.E.G, NULL);
2151       log_printmpi ("ecc_encrypt    n", pk.E.n);
2152       log_printmpi ("ecc_encrypt    q", mpi_q);
2153     }
2154   if (!pk.E.p || !pk.E.a || !pk.E.b || !pk.E.G.x || !pk.E.n || !mpi_q)
2155     {
2156       rc = GPG_ERR_NO_OBJ;
2157       goto leave;
2158     }
2159
2160   /* Convert the public key.  */
2161   if (mpi_q)
2162     {
2163       point_init (&pk.Q);
2164       rc = _gcry_ecc_os2ec (&pk.Q, mpi_q);
2165       if (rc)
2166         goto leave;
2167     }
2168
2169   /* Compute the encrypted value.  */
2170   ec = _gcry_mpi_ec_p_internal_new (pk.E.model, pk.E.dialect,
2171                                     pk.E.p, pk.E.a, pk.E.b);
2172
2173   /* The following is false: assert( mpi_cmp_ui( R.x, 1 )==0 );, so */
2174   {
2175     mpi_point_struct R;  /* Result that we return.  */
2176     gcry_mpi_t x, y;
2177
2178     x = mpi_new (0);
2179     y = mpi_new (0);
2180
2181     point_init (&R);
2182
2183     /* R = kQ  <=>  R = kdG  */
2184     _gcry_mpi_ec_mul_point (&R, data, &pk.Q, ec);
2185
2186     if (_gcry_mpi_ec_get_affine (x, y, &R, ec))
2187       log_fatal ("ecdh: Failed to get affine coordinates for kdG\n");
2188     mpi_s = _gcry_ecc_ec2os (x, y, pk.E.p);
2189
2190     /* R = kG */
2191     _gcry_mpi_ec_mul_point (&R, data, &pk.E.G, ec);
2192
2193     if (_gcry_mpi_ec_get_affine (x, y, &R, ec))
2194       log_fatal ("ecdh: Failed to get affine coordinates for kG\n");
2195     mpi_e = _gcry_ecc_ec2os (x, y, pk.E.p);
2196
2197     mpi_free (x);
2198     mpi_free (y);
2199
2200     point_free (&R);
2201   }
2202
2203   rc = gcry_sexp_build (r_ciph, NULL, "(enc-val(ecdh(s%m)(e%m)))",
2204                         mpi_s, mpi_e);
2205
2206  leave:
2207   gcry_mpi_release (pk.E.p);
2208   gcry_mpi_release (pk.E.a);
2209   gcry_mpi_release (pk.E.b);
2210   gcry_mpi_release (mpi_g);
2211   point_free (&pk.E.G);
2212   gcry_mpi_release (pk.E.n);
2213   gcry_mpi_release (mpi_q);
2214   point_free (&pk.Q);
2215   gcry_mpi_release (data);
2216   gcry_mpi_release (mpi_s);
2217   gcry_mpi_release (mpi_e);
2218   gcry_free (curvename);
2219   _gcry_mpi_ec_free (ec);
2220   _gcry_pk_util_free_encoding_ctx (&ctx);
2221   if (DBG_CIPHER)
2222     log_debug ("ecc_encrypt    => %s\n", gpg_strerror (rc));
2223   return rc;
2224 }
2225
2226
2227 /*  input:
2228  *     data[0] : a point kG (ephemeral public key)
2229  *   output:
2230  *     resaddr[0] : shared point kdG
2231  *
2232  *  see ecc_encrypt_raw for details.
2233  */
2234 static gcry_err_code_t
2235 ecc_decrypt_raw (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
2236 {
2237   gpg_err_code_t rc;
2238   struct pk_encoding_ctx ctx;
2239   gcry_sexp_t l1 = NULL;
2240   gcry_mpi_t data_e = NULL;
2241   ECC_secret_key sk;
2242   gcry_mpi_t mpi_g = NULL;
2243   char *curvename = NULL;
2244   mpi_ec_t ec = NULL;
2245   mpi_point_struct kG;
2246   mpi_point_struct R;
2247   gcry_mpi_t r = NULL;
2248
2249   memset (&sk, 0, sizeof sk);
2250   point_init (&kG);
2251   point_init (&R);
2252
2253   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_DECRYPT,
2254                                    ecc_get_nbits (keyparms));
2255
2256   /*
2257    * Extract the data.
2258    */
2259   rc = _gcry_pk_util_preparse_encval (s_data, ecc_names, &l1, &ctx);
2260   if (rc)
2261     goto leave;
2262   rc = _gcry_sexp_extract_param (l1, NULL, "e", &data_e, NULL);
2263   if (rc)
2264     goto leave;
2265   if (DBG_CIPHER)
2266     log_printmpi ("ecc_decrypt  d_e", data_e);
2267   if (mpi_is_opaque (data_e))
2268     {
2269       rc = GPG_ERR_INV_DATA;
2270       goto leave;
2271     }
2272
2273   /*
2274    * Extract the key.
2275    */
2276   rc = _gcry_sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?+d",
2277                                  &sk.E.p, &sk.E.a, &sk.E.b, &mpi_g, &sk.E.n,
2278                                  &sk.d, NULL);
2279   if (rc)
2280     goto leave;
2281   if (mpi_g)
2282     {
2283       point_init (&sk.E.G);
2284       rc = _gcry_ecc_os2ec (&sk.E.G, mpi_g);
2285       if (rc)
2286         goto leave;
2287     }
2288   /* Add missing parameters using the optional curve parameter.  */
2289   gcry_sexp_release (l1);
2290   l1 = gcry_sexp_find_token (keyparms, "curve", 5);
2291   if (l1)
2292     {
2293       curvename = gcry_sexp_nth_string (l1, 1);
2294       if (curvename)
2295         {
2296           rc = _gcry_ecc_fill_in_curve (0, curvename, &sk.E, NULL);
2297           if (rc)
2298             return rc;
2299         }
2300     }
2301   /* Guess required fields if a curve parameter has not been given.  */
2302   if (!curvename)
2303     {
2304       sk.E.model = MPI_EC_WEIERSTRASS;
2305       sk.E.dialect = ECC_DIALECT_STANDARD;
2306     }
2307   if (DBG_CIPHER)
2308     {
2309       log_debug ("ecc_decrypt info: %s/%s\n",
2310                  _gcry_ecc_model2str (sk.E.model),
2311                  _gcry_ecc_dialect2str (sk.E.dialect));
2312       if (sk.E.name)
2313         log_debug  ("ecc_decrypt name: %s\n", sk.E.name);
2314       log_printmpi ("ecc_decrypt    p", sk.E.p);
2315       log_printmpi ("ecc_decrypt    a", sk.E.a);
2316       log_printmpi ("ecc_decrypt    b", sk.E.b);
2317       log_printpnt ("ecc_decrypt  g",   &sk.E.G, NULL);
2318       log_printmpi ("ecc_decrypt    n", sk.E.n);
2319       if (!fips_mode ())
2320         log_printmpi ("ecc_decrypt    d", sk.d);
2321     }
2322   if (!sk.E.p || !sk.E.a || !sk.E.b || !sk.E.G.x || !sk.E.n || !sk.d)
2323     {
2324       rc = GPG_ERR_NO_OBJ;
2325       goto leave;
2326     }
2327
2328
2329   /*
2330    * Compute the plaintext.
2331    */
2332   rc = _gcry_ecc_os2ec (&kG, data_e);
2333   if (rc)
2334     {
2335       point_free (&kG);
2336       return rc;
2337     }
2338
2339   ec = _gcry_mpi_ec_p_internal_new (sk.E.model, sk.E.dialect,
2340                                     sk.E.p, sk.E.a, sk.E.b);
2341
2342   /* R = dkG */
2343   _gcry_mpi_ec_mul_point (&R, sk.d, &kG, ec);
2344
2345   /* The following is false: assert( mpi_cmp_ui( R.x, 1 )==0 );, so:  */
2346   {
2347     gcry_mpi_t x, y;
2348
2349     x = mpi_new (0);
2350     y = mpi_new (0);
2351
2352     if (_gcry_mpi_ec_get_affine (x, y, &R, ec))
2353       log_fatal ("ecdh: Failed to get affine coordinates\n");
2354
2355     r = _gcry_ecc_ec2os (x, y, sk.E.p);
2356     if (!r)
2357       rc = gpg_err_code_from_syserror ();
2358     else
2359       rc = 0;
2360     mpi_free (x);
2361     mpi_free (y);
2362   }
2363   if (DBG_CIPHER)
2364     log_printmpi ("ecc_decrypt  res", r);
2365
2366   if (!rc)
2367     rc = gcry_sexp_build (r_plain, NULL, "(value %m)", r);
2368
2369  leave:
2370   point_free (&R);
2371   point_free (&kG);
2372   gcry_mpi_release (r);
2373   gcry_mpi_release (sk.E.p);
2374   gcry_mpi_release (sk.E.a);
2375   gcry_mpi_release (sk.E.b);
2376   gcry_mpi_release (mpi_g);
2377   point_free (&sk.E.G);
2378   gcry_mpi_release (sk.E.n);
2379   gcry_mpi_release (sk.d);
2380   gcry_mpi_release (data_e);
2381   gcry_free (curvename);
2382   gcry_sexp_release (l1);
2383   _gcry_mpi_ec_free (ec);
2384   _gcry_pk_util_free_encoding_ctx (&ctx);
2385   if (DBG_CIPHER)
2386     log_debug ("ecc_decrypt    => %s\n", gpg_strerror (rc));
2387   return rc;
2388 }
2389
2390
2391 /* Return the number of bits for the key described by PARMS.  On error
2392  * 0 is returned.  The format of PARMS starts with the algorithm name;
2393  * for example:
2394  *
2395  *   (ecc
2396  *     (p <mpi>)
2397  *     (a <mpi>)
2398  *     (b <mpi>)
2399  *     (g <mpi>)
2400  *     (n <mpi>)
2401  *     (q <mpi>))
2402  *
2403  * More parameters may be given currently P is needed.  FIXME: We
2404  * need allow for a "curve" parameter.
2405  */
2406 static unsigned int
2407 ecc_get_nbits (gcry_sexp_t parms)
2408 {
2409   gcry_sexp_t l1;
2410   gcry_mpi_t p;
2411   unsigned int nbits = 0;
2412   char *curve;
2413
2414   l1 = gcry_sexp_find_token (parms, "p", 1);
2415   if (!l1)
2416     { /* Parameter P not found - check whether we have "curve".  */
2417       l1 = gcry_sexp_find_token (parms, "curve", 5);
2418       if (!l1)
2419         return 0; /* Neither P nor CURVE found.  */
2420
2421       curve = _gcry_sexp_nth_string (l1, 1);
2422       gcry_sexp_release (l1);
2423       if (!curve)
2424         return 0;  /* No curve name given (or out of core). */
2425
2426       if (_gcry_ecc_fill_in_curve (0, curve, NULL, &nbits))
2427         nbits = 0;
2428       gcry_free (curve);
2429     }
2430   else
2431     {
2432       p = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
2433       gcry_sexp_release (l1);
2434       if (p)
2435         {
2436           nbits = mpi_get_nbits (p);
2437           gcry_mpi_release (p);
2438         }
2439     }
2440   return nbits;
2441 }
2442
2443
2444 /* See rsa.c for a description of this function.  */
2445 static gpg_err_code_t
2446 compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparam)
2447 {
2448 #define N_COMPONENTS 6
2449   static const char names[N_COMPONENTS+1] = "pabgnq";
2450   gpg_err_code_t ec = 0;
2451   gcry_sexp_t l1;
2452   gcry_mpi_t values[N_COMPONENTS];
2453   int idx;
2454
2455   /* Clear the values for easier error cleanup.  */
2456   for (idx=0; idx < N_COMPONENTS; idx++)
2457     values[idx] = NULL;
2458
2459   /* Fill values with all provided parameters.  */
2460   for (idx=0; idx < N_COMPONENTS; idx++)
2461     {
2462       l1 = gcry_sexp_find_token (keyparam, names+idx, 1);
2463       if (l1)
2464         {
2465           values[idx] = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
2466           gcry_sexp_release (l1);
2467           if (!values[idx])
2468             {
2469               ec = GPG_ERR_INV_OBJ;
2470               goto leave;
2471             }
2472         }
2473     }
2474
2475   /* Check whether a curve parameter is available and use that to fill
2476      in missing values.  */
2477   l1 = gcry_sexp_find_token (keyparam, "curve", 5);
2478   if (l1)
2479     {
2480       char *curve;
2481       gcry_mpi_t tmpvalues[N_COMPONENTS];
2482
2483       for (idx = 0; idx < N_COMPONENTS; idx++)
2484         tmpvalues[idx] = NULL;
2485
2486       curve = _gcry_sexp_nth_string (l1, 1);
2487       gcry_sexp_release (l1);
2488       if (!curve)
2489         {
2490           ec = GPG_ERR_INV_OBJ; /* Name missing or out of core. */
2491           goto leave;
2492         }
2493       ec = _gcry_ecc_get_param (curve, tmpvalues);
2494       gcry_free (curve);
2495       if (ec)
2496         goto leave;
2497
2498       for (idx = 0; idx < N_COMPONENTS; idx++)
2499         {
2500           if (!values[idx])
2501             values[idx] = tmpvalues[idx];
2502           else
2503             mpi_free (tmpvalues[idx]);
2504         }
2505     }
2506
2507   /* Check that all parameters are known and normalize all MPIs (that
2508      should not be required but we use an internal function later and
2509      thus we better make 100% sure that they are normalized). */
2510   for (idx = 0; idx < N_COMPONENTS; idx++)
2511     if (!values[idx])
2512       {
2513         ec = GPG_ERR_NO_OBJ;
2514         goto leave;
2515       }
2516     else
2517       _gcry_mpi_normalize (values[idx]);
2518
2519   /* Hash them all.  */
2520   for (idx = 0; idx < N_COMPONENTS; idx++)
2521     {
2522       char buf[30];
2523       unsigned char *rawmpi;
2524       unsigned int rawmpilen;
2525
2526       rawmpi = _gcry_mpi_get_buffer (values[idx], 0, &rawmpilen, NULL);
2527       if (!rawmpi)
2528         {
2529           ec = gpg_err_code_from_syserror ();
2530           goto leave;
2531         }
2532       snprintf (buf, sizeof buf, "(1:%c%u:", names[idx], rawmpilen);
2533       gcry_md_write (md, buf, strlen (buf));
2534       gcry_md_write (md, rawmpi, rawmpilen);
2535       gcry_md_write (md, ")", 1);
2536       gcry_free (rawmpi);
2537     }
2538
2539  leave:
2540   for (idx = 0; idx < N_COMPONENTS; idx++)
2541     _gcry_mpi_release (values[idx]);
2542
2543   return ec;
2544 #undef N_COMPONENTS
2545 }
2546
2547
2548 \f
2549 /*
2550    Low-level API helper functions.
2551  */
2552
2553 /* This is the worker function for gcry_pubkey_get_sexp for ECC
2554    algorithms.  Note that the caller has already stored NULL at
2555    R_SEXP.  */
2556 gpg_err_code_t
2557 _gcry_pk_ecc_get_sexp (gcry_sexp_t *r_sexp, int mode, mpi_ec_t ec)
2558 {
2559   gpg_err_code_t rc;
2560   gcry_mpi_t mpi_G = NULL;
2561   gcry_mpi_t mpi_Q = NULL;
2562
2563   if (!ec->p || !ec->a || !ec->b || !ec->G || !ec->n)
2564     return GPG_ERR_BAD_CRYPT_CTX;
2565
2566   if (mode == GCRY_PK_GET_SECKEY && !ec->d)
2567     return GPG_ERR_NO_SECKEY;
2568
2569   /* Compute the public point if it is missing.  */
2570   if (!ec->Q && ec->d)
2571     ec->Q = _gcry_ecc_compute_public (NULL, ec);
2572
2573   /* Encode G and Q.  */
2574   mpi_G = _gcry_mpi_ec_ec2os (ec->G, ec);
2575   if (!mpi_G)
2576     {
2577       rc = GPG_ERR_BROKEN_PUBKEY;
2578       goto leave;
2579     }
2580   if (!ec->Q)
2581     {
2582       rc = GPG_ERR_BAD_CRYPT_CTX;
2583       goto leave;
2584     }
2585
2586   if (ec->dialect == ECC_DIALECT_ED25519)
2587     {
2588       unsigned char *encpk;
2589       unsigned int encpklen;
2590
2591       rc = _gcry_ecc_eddsa_encodepoint (ec->Q, ec, NULL, NULL,
2592                                         &encpk, &encpklen);
2593       if (rc)
2594         goto leave;
2595       mpi_Q = gcry_mpi_set_opaque (NULL, encpk, encpklen*8);
2596       encpk = NULL;
2597     }
2598   else
2599     {
2600       mpi_Q = _gcry_mpi_ec_ec2os (ec->Q, ec);
2601     }
2602   if (!mpi_Q)
2603     {
2604       rc = GPG_ERR_BROKEN_PUBKEY;
2605       goto leave;
2606     }
2607
2608   /* Fixme: We should return a curve name instead of the parameters if
2609      if know that they match a curve.  */
2610
2611   if (ec->d && (!mode || mode == GCRY_PK_GET_SECKEY))
2612     {
2613       /* Let's return a private key. */
2614       rc = gcry_sexp_build
2615         (r_sexp, NULL,
2616          "(private-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))",
2617          ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q, ec->d);
2618     }
2619   else if (ec->Q)
2620     {
2621       /* Let's return a public key.  */
2622       rc = gcry_sexp_build
2623         (r_sexp, NULL,
2624          "(public-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))",
2625          ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q);
2626     }
2627   else
2628     rc = GPG_ERR_BAD_CRYPT_CTX;
2629
2630  leave:
2631   mpi_free (mpi_Q);
2632   mpi_free (mpi_G);
2633   return rc;
2634 }
2635
2636
2637 \f
2638 /*
2639      Self-test section.
2640  */
2641
2642
2643 static gpg_err_code_t
2644 selftests_ecdsa (selftest_report_func_t report)
2645 {
2646   const char *what;
2647   const char *errtxt;
2648
2649   what = "low-level";
2650   errtxt = NULL; /*selftest ();*/
2651   if (errtxt)
2652     goto failed;
2653
2654   /* FIXME:  need more tests.  */
2655
2656   return 0; /* Succeeded. */
2657
2658  failed:
2659   if (report)
2660     report ("pubkey", GCRY_PK_ECC, what, errtxt);
2661   return GPG_ERR_SELFTEST_FAILED;
2662 }
2663
2664
2665 /* Run a full self-test for ALGO and return 0 on success.  */
2666 static gpg_err_code_t
2667 run_selftests (int algo, int extended, selftest_report_func_t report)
2668 {
2669   (void)extended;
2670
2671   if (algo != GCRY_PK_ECC)
2672     return GPG_ERR_PUBKEY_ALGO;
2673
2674   return selftests_ecdsa (report);
2675 }
2676
2677
2678
2679 \f
2680 gcry_pk_spec_t _gcry_pubkey_spec_ecc =
2681   {
2682     GCRY_PK_ECC, { 0, 0 },
2683     (GCRY_PK_USAGE_SIGN | GCRY_PK_USAGE_ENCR),
2684     "ECC", ecc_names,
2685     "pabgnq", "pabgnqd", "sw", "rs", "pabgnq",
2686     ecc_generate,
2687     ecc_check_secret_key,
2688     ecc_encrypt_raw,
2689     ecc_decrypt_raw,
2690     ecc_sign,
2691     ecc_verify,
2692     ecc_get_nbits,
2693     run_selftests,
2694     compute_keygrip,
2695     _gcry_ecc_get_param,
2696     _gcry_ecc_get_curve,
2697     _gcry_ecc_get_param_sexp
2698   };