ecc: Add support for GOST R 34.10-2001/-2012 signatures
[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_info, 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_info);
1617   return rc;
1618 }
1619
1620
1621 static gcry_err_code_t
1622 ecc_check_secret_key (gcry_sexp_t keyparms)
1623 {
1624   gcry_err_code_t rc;
1625   gcry_sexp_t l1 = NULL;
1626   char *curvename = NULL;
1627   gcry_mpi_t mpi_g = NULL;
1628   gcry_mpi_t mpi_q = NULL;
1629   ECC_secret_key sk;
1630
1631   memset (&sk, 0, sizeof sk);
1632
1633   /*
1634    * Extract the key.
1635    */
1636   rc = _gcry_sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?/q?+d",
1637                                  &sk.E.p, &sk.E.a, &sk.E.b, &mpi_g, &sk.E.n,
1638                                  &mpi_q, &sk.d, NULL);
1639   if (rc)
1640     goto leave;
1641   if (mpi_g)
1642     {
1643       point_init (&sk.E.G);
1644       rc = _gcry_ecc_os2ec (&sk.E.G, mpi_g);
1645       if (rc)
1646         goto leave;
1647     }
1648   /* Add missing parameters using the optional curve parameter.  */
1649   gcry_sexp_release (l1);
1650   l1 = gcry_sexp_find_token (keyparms, "curve", 5);
1651   if (l1)
1652     {
1653       curvename = gcry_sexp_nth_string (l1, 1);
1654       if (curvename)
1655         {
1656           rc = _gcry_ecc_fill_in_curve (0, curvename, &sk.E, NULL);
1657           if (rc)
1658             return rc;
1659         }
1660     }
1661   /* Guess required fields if a curve parameter has not been given.
1662      FIXME: This is a crude hacks.  We need to fix that.  */
1663   if (!curvename)
1664     {
1665       sk.E.model = MPI_EC_WEIERSTRASS;
1666       sk.E.dialect = ECC_DIALECT_STANDARD;
1667     }
1668   if (DBG_CIPHER)
1669     {
1670       log_debug ("ecc_testkey inf: %s/%s\n",
1671                  _gcry_ecc_model2str (sk.E.model),
1672                  _gcry_ecc_dialect2str (sk.E.dialect));
1673       if (sk.E.name)
1674         log_debug  ("ecc_testkey nam: %s\n", sk.E.name);
1675       log_printmpi ("ecc_testkey   p", sk.E.p);
1676       log_printmpi ("ecc_testkey   a", sk.E.a);
1677       log_printmpi ("ecc_testkey   b", sk.E.b);
1678       log_printpnt ("ecc_testkey g",   &sk.E.G, NULL);
1679       log_printmpi ("ecc_testkey   n", sk.E.n);
1680       log_printmpi ("ecc_testkey   q", mpi_q);
1681       if (!fips_mode ())
1682         log_printmpi ("ecc_testkey   d", sk.d);
1683     }
1684   if (!sk.E.p || !sk.E.a || !sk.E.b || !sk.E.G.x || !sk.E.n || !sk.d)
1685     {
1686       rc = GPG_ERR_NO_OBJ;
1687       goto leave;
1688     }
1689
1690   if (mpi_q)
1691     {
1692       point_init (&sk.Q);
1693       rc = _gcry_ecc_os2ec (&sk.Q, mpi_q);
1694       if (rc)
1695         goto leave;
1696     }
1697   else
1698     {
1699       /* The current test requires Q.  */
1700       rc = GPG_ERR_NO_OBJ;
1701       goto leave;
1702     }
1703
1704   if (check_secret_key (&sk))
1705     rc = GPG_ERR_BAD_SECKEY;
1706
1707  leave:
1708   gcry_mpi_release (sk.E.p);
1709   gcry_mpi_release (sk.E.a);
1710   gcry_mpi_release (sk.E.b);
1711   gcry_mpi_release (mpi_g);
1712   point_free (&sk.E.G);
1713   gcry_mpi_release (sk.E.n);
1714   gcry_mpi_release (mpi_q);
1715   point_free (&sk.Q);
1716   gcry_mpi_release (sk.d);
1717   gcry_free (curvename);
1718   gcry_sexp_release (l1);
1719   if (DBG_CIPHER)
1720     log_debug ("ecc_testkey   => %s\n", gpg_strerror (rc));
1721   return rc;
1722 }
1723
1724
1725 static gcry_err_code_t
1726 ecc_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
1727 {
1728   gcry_err_code_t rc;
1729   struct pk_encoding_ctx ctx;
1730   gcry_mpi_t data = NULL;
1731   gcry_sexp_t l1 = NULL;
1732   char *curvename = NULL;
1733   gcry_mpi_t mpi_g = NULL;
1734   gcry_mpi_t mpi_q = NULL;
1735   ECC_secret_key sk;
1736   gcry_mpi_t sig_r = NULL;
1737   gcry_mpi_t sig_s = NULL;
1738
1739   memset (&sk, 0, sizeof sk);
1740
1741   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_SIGN, 0);
1742
1743   /* Extract the data.  */
1744   rc = _gcry_pk_util_data_to_mpi (s_data, &data, &ctx);
1745   if (rc)
1746     goto leave;
1747   if (DBG_CIPHER)
1748     log_mpidump ("ecc_sign   data", data);
1749
1750   /*
1751    * Extract the key.
1752    */
1753   rc = _gcry_sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?/q?+d",
1754                                  &sk.E.p, &sk.E.a, &sk.E.b, &mpi_g, &sk.E.n,
1755                                  &mpi_q, &sk.d, NULL);
1756   if (rc)
1757     goto leave;
1758   if (mpi_g)
1759     {
1760       point_init (&sk.E.G);
1761       rc = _gcry_ecc_os2ec (&sk.E.G, mpi_g);
1762       if (rc)
1763         goto leave;
1764     }
1765   /* Add missing parameters using the optional curve parameter.  */
1766   gcry_sexp_release (l1);
1767   l1 = gcry_sexp_find_token (keyparms, "curve", 5);
1768   if (l1)
1769     {
1770       curvename = gcry_sexp_nth_string (l1, 1);
1771       if (curvename)
1772         {
1773           rc = _gcry_ecc_fill_in_curve (0, curvename, &sk.E, NULL);
1774           if (rc)
1775             return rc;
1776         }
1777     }
1778   /* Guess required fields if a curve parameter has not been given.
1779      FIXME: This is a crude hacks.  We need to fix that.  */
1780   if (!curvename)
1781     {
1782       sk.E.model = ((ctx.flags & PUBKEY_FLAG_EDDSA)
1783                     ? MPI_EC_TWISTEDEDWARDS
1784                     : MPI_EC_WEIERSTRASS);
1785       sk.E.dialect = ((ctx.flags & PUBKEY_FLAG_EDDSA)
1786                       ? ECC_DIALECT_ED25519
1787                       : ECC_DIALECT_STANDARD);
1788     }
1789   if (DBG_CIPHER)
1790     {
1791       log_debug ("ecc_sign   info: %s/%s%s\n",
1792                  _gcry_ecc_model2str (sk.E.model),
1793                  _gcry_ecc_dialect2str (sk.E.dialect),
1794                  (sk.E.dialect == ECC_DIALECT_ED25519
1795                   && (ctx.flags & PUBKEY_FLAG_ECDSA))? "ECDSA":"");
1796       if (sk.E.name)
1797         log_debug  ("ecc_sign   name: %s\n", sk.E.name);
1798       log_printmpi ("ecc_sign      p", sk.E.p);
1799       log_printmpi ("ecc_sign      a", sk.E.a);
1800       log_printmpi ("ecc_sign      b", sk.E.b);
1801       log_printpnt ("ecc_sign    g",   &sk.E.G, NULL);
1802       log_printmpi ("ecc_sign      n", sk.E.n);
1803       log_printmpi ("ecc_sign      q", mpi_q);
1804       if (!fips_mode ())
1805         log_printmpi ("ecc_sign      d", sk.d);
1806     }
1807   if (!sk.E.p || !sk.E.a || !sk.E.b || !sk.E.G.x || !sk.E.n || !sk.d)
1808     {
1809       rc = GPG_ERR_NO_OBJ;
1810       goto leave;
1811     }
1812
1813
1814   sig_r = gcry_mpi_new (0);
1815   sig_s = gcry_mpi_new (0);
1816   if ((ctx.flags & PUBKEY_FLAG_EDDSA))
1817     {
1818       /* EdDSA requires the public key.  */
1819       rc = sign_eddsa (data, &sk, sig_r, sig_s, ctx.hash_algo, mpi_q);
1820       if (!rc)
1821         rc = gcry_sexp_build (r_sig, NULL,
1822                               "(sig-val(eddsa(r%M)(s%M)))", sig_r, sig_s);
1823     }
1824   else if ((ctx.flags & PUBKEY_FLAG_GOST))
1825     {
1826       rc = sign_gost (data, &sk, sig_r, sig_s);
1827       if (!rc)
1828         rc = gcry_sexp_build (r_sig, NULL,
1829                               "(sig-val(gost(r%M)(s%M)))", sig_r, sig_s);
1830     }
1831   else
1832     {
1833       rc = sign_ecdsa (data, &sk, sig_r, sig_s, ctx.flags, ctx.hash_algo);
1834       if (!rc)
1835         rc = gcry_sexp_build (r_sig, NULL,
1836                               "(sig-val(ecdsa(r%M)(s%M)))", sig_r, sig_s);
1837     }
1838
1839
1840  leave:
1841   gcry_mpi_release (sk.E.p);
1842   gcry_mpi_release (sk.E.a);
1843   gcry_mpi_release (sk.E.b);
1844   gcry_mpi_release (mpi_g);
1845   point_free (&sk.E.G);
1846   gcry_mpi_release (sk.E.n);
1847   gcry_mpi_release (mpi_q);
1848   point_free (&sk.Q);
1849   gcry_mpi_release (sk.d);
1850   gcry_mpi_release (sig_r);
1851   gcry_mpi_release (sig_s);
1852   gcry_free (curvename);
1853   gcry_mpi_release (data);
1854   gcry_sexp_release (l1);
1855   _gcry_pk_util_free_encoding_ctx (&ctx);
1856   if (DBG_CIPHER)
1857     log_debug ("ecc_sign      => %s\n", gpg_strerror (rc));
1858   return rc;
1859 }
1860
1861
1862 static gcry_err_code_t
1863 ecc_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t s_keyparms)
1864 {
1865   gcry_err_code_t rc;
1866   struct pk_encoding_ctx ctx;
1867   gcry_sexp_t l1 = NULL;
1868   char *curvename = NULL;
1869   gcry_mpi_t mpi_g = NULL;
1870   gcry_mpi_t mpi_q = NULL;
1871   gcry_mpi_t sig_r = NULL;
1872   gcry_mpi_t sig_s = NULL;
1873   gcry_mpi_t data = NULL;
1874   ECC_public_key pk;
1875   int sigflags;
1876
1877   memset (&pk, 0, sizeof pk);
1878   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_VERIFY,
1879                                    ecc_get_nbits (s_keyparms));
1880
1881   /* Extract the data.  */
1882   rc = _gcry_pk_util_data_to_mpi (s_data, &data, &ctx);
1883   if (rc)
1884     goto leave;
1885   if (DBG_CIPHER)
1886     log_mpidump ("ecc_verify data", data);
1887
1888   /*
1889    * Extract the signature value.
1890    */
1891   rc = _gcry_pk_util_preparse_sigval (s_sig, ecc_names, &l1, &sigflags);
1892   if (rc)
1893     goto leave;
1894   rc = _gcry_sexp_extract_param (l1, NULL,
1895                                  (sigflags & PUBKEY_FLAG_EDDSA)? "/rs":"rs",
1896                                  &sig_r, &sig_s, NULL);
1897   if (rc)
1898     goto leave;
1899   if (DBG_CIPHER)
1900     {
1901       log_mpidump ("ecc_verify  s_r", sig_r);
1902       log_mpidump ("ecc_verify  s_s", sig_s);
1903     }
1904   if ((ctx.flags & PUBKEY_FLAG_EDDSA) ^ (sigflags & PUBKEY_FLAG_EDDSA))
1905     {
1906       rc = GPG_ERR_CONFLICT; /* Inconsistent use of flag/algoname.  */
1907       goto leave;
1908     }
1909
1910
1911   /*
1912    * Extract the key.
1913    */
1914   rc = _gcry_sexp_extract_param (s_keyparms, NULL, "-p?a?b?g?n?/q?",
1915                                  &pk.E.p, &pk.E.a, &pk.E.b, &mpi_g, &pk.E.n,
1916                                  &mpi_q, NULL);
1917   if (rc)
1918     goto leave;
1919   if (mpi_g)
1920     {
1921       point_init (&pk.E.G);
1922       rc = _gcry_ecc_os2ec (&pk.E.G, mpi_g);
1923       if (rc)
1924         goto leave;
1925     }
1926   /* Add missing parameters using the optional curve parameter.  */
1927   gcry_sexp_release (l1);
1928   l1 = gcry_sexp_find_token (s_keyparms, "curve", 5);
1929   if (l1)
1930     {
1931       curvename = gcry_sexp_nth_string (l1, 1);
1932       if (curvename)
1933         {
1934           rc = _gcry_ecc_fill_in_curve (0, curvename, &pk.E, NULL);
1935           if (rc)
1936             return rc;
1937         }
1938     }
1939   /* Guess required fields if a curve parameter has not been given.
1940      FIXME: This is a crude hacks.  We need to fix that.  */
1941   if (!curvename)
1942     {
1943       pk.E.model = ((sigflags & PUBKEY_FLAG_EDDSA)
1944                     ? MPI_EC_TWISTEDEDWARDS
1945                     : MPI_EC_WEIERSTRASS);
1946       pk.E.dialect = ((sigflags & PUBKEY_FLAG_EDDSA)
1947                       ? ECC_DIALECT_ED25519
1948                       : ECC_DIALECT_STANDARD);
1949     }
1950
1951   if (DBG_CIPHER)
1952     {
1953       log_debug ("ecc_verify info: %s/%s%s\n",
1954                  _gcry_ecc_model2str (pk.E.model),
1955                  _gcry_ecc_dialect2str (pk.E.dialect),
1956                  (pk.E.dialect == ECC_DIALECT_ED25519
1957                   && !(sigflags & PUBKEY_FLAG_EDDSA))? "/ECDSA":"");
1958       if (pk.E.name)
1959         log_debug  ("ecc_verify name: %s\n", pk.E.name);
1960       log_printmpi ("ecc_verify    p", pk.E.p);
1961       log_printmpi ("ecc_verify    a", pk.E.a);
1962       log_printmpi ("ecc_verify    b", pk.E.b);
1963       log_printpnt ("ecc_verify  g",   &pk.E.G, NULL);
1964       log_printmpi ("ecc_verify    n", pk.E.n);
1965       log_printmpi ("ecc_verify    q", mpi_q);
1966     }
1967   if (!pk.E.p || !pk.E.a || !pk.E.b || !pk.E.G.x || !pk.E.n || !mpi_q)
1968     {
1969       rc = GPG_ERR_NO_OBJ;
1970       goto leave;
1971     }
1972
1973
1974   /*
1975    * Verify the signature.
1976    */
1977   if ((sigflags & PUBKEY_FLAG_EDDSA))
1978     {
1979       rc = verify_eddsa (data, &pk, sig_r, sig_s, ctx.hash_algo, mpi_q);
1980     }
1981   else if ((sigflags & PUBKEY_FLAG_GOST))
1982     {
1983       point_init (&pk.Q);
1984       rc = _gcry_ecc_os2ec (&pk.Q, mpi_q);
1985       if (rc)
1986         goto leave;
1987
1988       rc = verify_gost (data, &pk, sig_r, sig_s);
1989     }
1990   else
1991     {
1992       point_init (&pk.Q);
1993       rc = _gcry_ecc_os2ec (&pk.Q, mpi_q);
1994       if (rc)
1995         goto leave;
1996
1997       if (mpi_is_opaque (data))
1998         {
1999           const void *abuf;
2000           unsigned int abits, qbits;
2001           gcry_mpi_t a;
2002
2003           qbits = mpi_get_nbits (pk.E.n);
2004
2005           abuf = gcry_mpi_get_opaque (data, &abits);
2006           rc = gpg_err_code (gcry_mpi_scan (&a, GCRYMPI_FMT_USG,
2007                                             abuf, (abits+7)/8, NULL));
2008           if (!rc)
2009             {
2010               if (abits > qbits)
2011                 gcry_mpi_rshift (a, a, abits - qbits);
2012
2013               rc = verify_ecdsa (a, &pk, sig_r, sig_s);
2014               gcry_mpi_release (a);
2015             }
2016         }
2017       else
2018         rc = verify_ecdsa (data, &pk, sig_r, sig_s);
2019     }
2020
2021  leave:
2022   gcry_mpi_release (pk.E.p);
2023   gcry_mpi_release (pk.E.a);
2024   gcry_mpi_release (pk.E.b);
2025   gcry_mpi_release (mpi_g);
2026   point_free (&pk.E.G);
2027   gcry_mpi_release (pk.E.n);
2028   gcry_mpi_release (mpi_q);
2029   point_free (&pk.Q);
2030   gcry_mpi_release (data);
2031   gcry_mpi_release (sig_r);
2032   gcry_mpi_release (sig_s);
2033   gcry_free (curvename);
2034   gcry_sexp_release (l1);
2035   _gcry_pk_util_free_encoding_ctx (&ctx);
2036   if (DBG_CIPHER)
2037     log_debug ("ecc_verify    => %s\n", rc?gpg_strerror (rc):"Good");
2038   return rc;
2039 }
2040
2041
2042 /* ecdh raw is classic 2-round DH protocol published in 1976.
2043  *
2044  * Overview of ecc_encrypt_raw and ecc_decrypt_raw.
2045  *
2046  * As with any PK operation, encrypt version uses a public key and
2047  * decrypt -- private.
2048  *
2049  * Symbols used below:
2050  *     G - field generator point
2051  *     d - private long-term scalar
2052  *    dG - public long-term key
2053  *     k - ephemeral scalar
2054  *    kG - ephemeral public key
2055  *   dkG - shared secret
2056  *
2057  * ecc_encrypt_raw description:
2058  *   input:
2059  *     data[0] : private scalar (k)
2060  *   output: A new S-expression with the parameters:
2061  *     s : shared point (kdG)
2062  *     e : generated ephemeral public key (kG)
2063  *
2064  * ecc_decrypt_raw description:
2065  *   input:
2066  *     data[0] : a point kG (ephemeral public key)
2067  *   output:
2068  *     result[0] : shared point (kdG)
2069  */
2070 static gcry_err_code_t
2071 ecc_encrypt_raw (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t keyparms)
2072 {
2073   gcry_err_code_t rc;
2074   struct pk_encoding_ctx ctx;
2075   gcry_sexp_t l1 = NULL;
2076   char *curvename = NULL;
2077   gcry_mpi_t mpi_g = NULL;
2078   gcry_mpi_t mpi_q = NULL;
2079   gcry_mpi_t mpi_s = NULL;
2080   gcry_mpi_t mpi_e = NULL;
2081   gcry_mpi_t data = NULL;
2082   ECC_public_key pk;
2083   mpi_ec_t ec = NULL;
2084
2085   memset (&pk, 0, sizeof pk);
2086   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_ENCRYPT,
2087                                    ecc_get_nbits (keyparms));
2088
2089   /*
2090    * Extract the data.
2091    */
2092   rc = _gcry_pk_util_data_to_mpi (s_data, &data, &ctx);
2093   if (rc)
2094     goto leave;
2095   if (DBG_CIPHER)
2096     log_mpidump ("ecc_encrypt data", data);
2097   if (mpi_is_opaque (data))
2098     {
2099       rc = GPG_ERR_INV_DATA;
2100       goto leave;
2101     }
2102
2103
2104   /*
2105    * Extract the key.
2106    */
2107   rc = _gcry_sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?+q",
2108                                  &pk.E.p, &pk.E.a, &pk.E.b, &mpi_g, &pk.E.n,
2109                                  &mpi_q, NULL);
2110   if (rc)
2111     goto leave;
2112   if (mpi_g)
2113     {
2114       point_init (&pk.E.G);
2115       rc = _gcry_ecc_os2ec (&pk.E.G, mpi_g);
2116       if (rc)
2117         goto leave;
2118     }
2119   /* Add missing parameters using the optional curve parameter.  */
2120   gcry_sexp_release (l1);
2121   l1 = gcry_sexp_find_token (keyparms, "curve", 5);
2122   if (l1)
2123     {
2124       curvename = gcry_sexp_nth_string (l1, 1);
2125       if (curvename)
2126         {
2127           rc = _gcry_ecc_fill_in_curve (0, curvename, &pk.E, NULL);
2128           if (rc)
2129             return rc;
2130         }
2131     }
2132   /* Guess required fields if a curve parameter has not been given.  */
2133   if (!curvename)
2134     {
2135       pk.E.model = MPI_EC_WEIERSTRASS;
2136       pk.E.dialect = ECC_DIALECT_STANDARD;
2137     }
2138
2139   if (DBG_CIPHER)
2140     {
2141       log_debug ("ecc_encrypt info: %s/%s\n",
2142                  _gcry_ecc_model2str (pk.E.model),
2143                  _gcry_ecc_dialect2str (pk.E.dialect));
2144       if (pk.E.name)
2145         log_debug  ("ecc_encrypt name: %s\n", pk.E.name);
2146       log_printmpi ("ecc_encrypt    p", pk.E.p);
2147       log_printmpi ("ecc_encrypt    a", pk.E.a);
2148       log_printmpi ("ecc_encrypt    b", pk.E.b);
2149       log_printpnt ("ecc_encrypt  g",   &pk.E.G, NULL);
2150       log_printmpi ("ecc_encrypt    n", pk.E.n);
2151       log_printmpi ("ecc_encrypt    q", mpi_q);
2152     }
2153   if (!pk.E.p || !pk.E.a || !pk.E.b || !pk.E.G.x || !pk.E.n || !mpi_q)
2154     {
2155       rc = GPG_ERR_NO_OBJ;
2156       goto leave;
2157     }
2158
2159   /* Convert the public key.  */
2160   if (mpi_q)
2161     {
2162       point_init (&pk.Q);
2163       rc = _gcry_ecc_os2ec (&pk.Q, mpi_q);
2164       if (rc)
2165         goto leave;
2166     }
2167
2168   /* Compute the encrypted value.  */
2169   ec = _gcry_mpi_ec_p_internal_new (pk.E.model, pk.E.dialect,
2170                                     pk.E.p, pk.E.a, pk.E.b);
2171
2172   /* The following is false: assert( mpi_cmp_ui( R.x, 1 )==0 );, so */
2173   {
2174     mpi_point_struct R;  /* Result that we return.  */
2175     gcry_mpi_t x, y;
2176
2177     x = mpi_new (0);
2178     y = mpi_new (0);
2179
2180     point_init (&R);
2181
2182     /* R = kQ  <=>  R = kdG  */
2183     _gcry_mpi_ec_mul_point (&R, data, &pk.Q, ec);
2184
2185     if (_gcry_mpi_ec_get_affine (x, y, &R, ec))
2186       log_fatal ("ecdh: Failed to get affine coordinates for kdG\n");
2187     mpi_s = _gcry_ecc_ec2os (x, y, pk.E.p);
2188
2189     /* R = kG */
2190     _gcry_mpi_ec_mul_point (&R, data, &pk.E.G, ec);
2191
2192     if (_gcry_mpi_ec_get_affine (x, y, &R, ec))
2193       log_fatal ("ecdh: Failed to get affine coordinates for kG\n");
2194     mpi_e = _gcry_ecc_ec2os (x, y, pk.E.p);
2195
2196     mpi_free (x);
2197     mpi_free (y);
2198
2199     point_free (&R);
2200   }
2201
2202   rc = gcry_sexp_build (r_ciph, NULL, "(enc-val(ecdh(s%m)(e%m)))",
2203                         mpi_s, mpi_e);
2204
2205  leave:
2206   gcry_mpi_release (pk.E.p);
2207   gcry_mpi_release (pk.E.a);
2208   gcry_mpi_release (pk.E.b);
2209   gcry_mpi_release (mpi_g);
2210   point_free (&pk.E.G);
2211   gcry_mpi_release (pk.E.n);
2212   gcry_mpi_release (mpi_q);
2213   point_free (&pk.Q);
2214   gcry_mpi_release (data);
2215   gcry_mpi_release (mpi_s);
2216   gcry_mpi_release (mpi_e);
2217   gcry_free (curvename);
2218   _gcry_mpi_ec_free (ec);
2219   _gcry_pk_util_free_encoding_ctx (&ctx);
2220   if (DBG_CIPHER)
2221     log_debug ("ecc_encrypt    => %s\n", gpg_strerror (rc));
2222   return rc;
2223 }
2224
2225
2226 /*  input:
2227  *     data[0] : a point kG (ephemeral public key)
2228  *   output:
2229  *     resaddr[0] : shared point kdG
2230  *
2231  *  see ecc_encrypt_raw for details.
2232  */
2233 static gcry_err_code_t
2234 ecc_decrypt_raw (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
2235 {
2236   gpg_err_code_t rc;
2237   struct pk_encoding_ctx ctx;
2238   gcry_sexp_t l1 = NULL;
2239   gcry_mpi_t data_e = NULL;
2240   ECC_secret_key sk;
2241   gcry_mpi_t mpi_g = NULL;
2242   char *curvename = NULL;
2243   mpi_ec_t ec = NULL;
2244   mpi_point_struct kG;
2245   mpi_point_struct R;
2246   gcry_mpi_t r = NULL;
2247
2248   memset (&sk, 0, sizeof sk);
2249   point_init (&kG);
2250   point_init (&R);
2251
2252   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_DECRYPT,
2253                                    ecc_get_nbits (keyparms));
2254
2255   /*
2256    * Extract the data.
2257    */
2258   rc = _gcry_pk_util_preparse_encval (s_data, ecc_names, &l1, &ctx);
2259   if (rc)
2260     goto leave;
2261   rc = _gcry_sexp_extract_param (l1, NULL, "e", &data_e, NULL);
2262   if (rc)
2263     goto leave;
2264   if (DBG_CIPHER)
2265     log_printmpi ("ecc_decrypt  d_e", data_e);
2266   if (mpi_is_opaque (data_e))
2267     {
2268       rc = GPG_ERR_INV_DATA;
2269       goto leave;
2270     }
2271
2272   /*
2273    * Extract the key.
2274    */
2275   rc = _gcry_sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?+d",
2276                                  &sk.E.p, &sk.E.a, &sk.E.b, &mpi_g, &sk.E.n,
2277                                  &sk.d, NULL);
2278   if (rc)
2279     goto leave;
2280   if (mpi_g)
2281     {
2282       point_init (&sk.E.G);
2283       rc = _gcry_ecc_os2ec (&sk.E.G, mpi_g);
2284       if (rc)
2285         goto leave;
2286     }
2287   /* Add missing parameters using the optional curve parameter.  */
2288   gcry_sexp_release (l1);
2289   l1 = gcry_sexp_find_token (keyparms, "curve", 5);
2290   if (l1)
2291     {
2292       curvename = gcry_sexp_nth_string (l1, 1);
2293       if (curvename)
2294         {
2295           rc = _gcry_ecc_fill_in_curve (0, curvename, &sk.E, NULL);
2296           if (rc)
2297             return rc;
2298         }
2299     }
2300   /* Guess required fields if a curve parameter has not been given.  */
2301   if (!curvename)
2302     {
2303       sk.E.model = MPI_EC_WEIERSTRASS;
2304       sk.E.dialect = ECC_DIALECT_STANDARD;
2305     }
2306   if (DBG_CIPHER)
2307     {
2308       log_debug ("ecc_decrypt info: %s/%s\n",
2309                  _gcry_ecc_model2str (sk.E.model),
2310                  _gcry_ecc_dialect2str (sk.E.dialect));
2311       if (sk.E.name)
2312         log_debug  ("ecc_decrypt name: %s\n", sk.E.name);
2313       log_printmpi ("ecc_decrypt    p", sk.E.p);
2314       log_printmpi ("ecc_decrypt    a", sk.E.a);
2315       log_printmpi ("ecc_decrypt    b", sk.E.b);
2316       log_printpnt ("ecc_decrypt  g",   &sk.E.G, NULL);
2317       log_printmpi ("ecc_decrypt    n", sk.E.n);
2318       if (!fips_mode ())
2319         log_printmpi ("ecc_decrypt    d", sk.d);
2320     }
2321   if (!sk.E.p || !sk.E.a || !sk.E.b || !sk.E.G.x || !sk.E.n || !sk.d)
2322     {
2323       rc = GPG_ERR_NO_OBJ;
2324       goto leave;
2325     }
2326
2327
2328   /*
2329    * Compute the plaintext.
2330    */
2331   rc = _gcry_ecc_os2ec (&kG, data_e);
2332   if (rc)
2333     {
2334       point_free (&kG);
2335       return rc;
2336     }
2337
2338   ec = _gcry_mpi_ec_p_internal_new (sk.E.model, sk.E.dialect,
2339                                     sk.E.p, sk.E.a, sk.E.b);
2340
2341   /* R = dkG */
2342   _gcry_mpi_ec_mul_point (&R, sk.d, &kG, ec);
2343
2344   /* The following is false: assert( mpi_cmp_ui( R.x, 1 )==0 );, so:  */
2345   {
2346     gcry_mpi_t x, y;
2347
2348     x = mpi_new (0);
2349     y = mpi_new (0);
2350
2351     if (_gcry_mpi_ec_get_affine (x, y, &R, ec))
2352       log_fatal ("ecdh: Failed to get affine coordinates\n");
2353
2354     r = _gcry_ecc_ec2os (x, y, sk.E.p);
2355     if (!r)
2356       rc = gpg_err_code_from_syserror ();
2357     else
2358       rc = 0;
2359     mpi_free (x);
2360     mpi_free (y);
2361   }
2362   if (DBG_CIPHER)
2363     log_printmpi ("ecc_decrypt  res", r);
2364
2365   if (!rc)
2366     rc = gcry_sexp_build (r_plain, NULL, "(value %m)", r);
2367
2368  leave:
2369   point_free (&R);
2370   point_free (&kG);
2371   gcry_mpi_release (r);
2372   gcry_mpi_release (sk.E.p);
2373   gcry_mpi_release (sk.E.a);
2374   gcry_mpi_release (sk.E.b);
2375   gcry_mpi_release (mpi_g);
2376   point_free (&sk.E.G);
2377   gcry_mpi_release (sk.E.n);
2378   gcry_mpi_release (sk.d);
2379   gcry_mpi_release (data_e);
2380   gcry_free (curvename);
2381   gcry_sexp_release (l1);
2382   _gcry_mpi_ec_free (ec);
2383   _gcry_pk_util_free_encoding_ctx (&ctx);
2384   if (DBG_CIPHER)
2385     log_debug ("ecc_decrypt    => %s\n", gpg_strerror (rc));
2386   return rc;
2387 }
2388
2389
2390 /* Return the number of bits for the key described by PARMS.  On error
2391  * 0 is returned.  The format of PARMS starts with the algorithm name;
2392  * for example:
2393  *
2394  *   (ecc
2395  *     (p <mpi>)
2396  *     (a <mpi>)
2397  *     (b <mpi>)
2398  *     (g <mpi>)
2399  *     (n <mpi>)
2400  *     (q <mpi>))
2401  *
2402  * More parameters may be given currently P is needed.  FIXME: We
2403  * need allow for a "curve" parameter.
2404  */
2405 static unsigned int
2406 ecc_get_nbits (gcry_sexp_t parms)
2407 {
2408   gcry_sexp_t l1;
2409   gcry_mpi_t p;
2410   unsigned int nbits = 0;
2411   char *curve;
2412
2413   l1 = gcry_sexp_find_token (parms, "p", 1);
2414   if (!l1)
2415     { /* Parameter P not found - check whether we have "curve".  */
2416       l1 = gcry_sexp_find_token (parms, "curve", 5);
2417       if (!l1)
2418         return 0; /* Neither P nor CURVE found.  */
2419
2420       curve = _gcry_sexp_nth_string (l1, 1);
2421       gcry_sexp_release (l1);
2422       if (!curve)
2423         return 0;  /* No curve name given (or out of core). */
2424
2425       if (_gcry_ecc_fill_in_curve (0, curve, NULL, &nbits))
2426         nbits = 0;
2427       gcry_free (curve);
2428     }
2429   else
2430     {
2431       p = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
2432       gcry_sexp_release (l1);
2433       if (p)
2434         {
2435           nbits = mpi_get_nbits (p);
2436           gcry_mpi_release (p);
2437         }
2438     }
2439   return nbits;
2440 }
2441
2442
2443 /* See rsa.c for a description of this function.  */
2444 static gpg_err_code_t
2445 compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparam)
2446 {
2447 #define N_COMPONENTS 6
2448   static const char names[N_COMPONENTS+1] = "pabgnq";
2449   gpg_err_code_t ec = 0;
2450   gcry_sexp_t l1;
2451   gcry_mpi_t values[N_COMPONENTS];
2452   int idx;
2453
2454   /* Clear the values for easier error cleanup.  */
2455   for (idx=0; idx < N_COMPONENTS; idx++)
2456     values[idx] = NULL;
2457
2458   /* Fill values with all provided parameters.  */
2459   for (idx=0; idx < N_COMPONENTS; idx++)
2460     {
2461       l1 = gcry_sexp_find_token (keyparam, names+idx, 1);
2462       if (l1)
2463         {
2464           values[idx] = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
2465           gcry_sexp_release (l1);
2466           if (!values[idx])
2467             {
2468               ec = GPG_ERR_INV_OBJ;
2469               goto leave;
2470             }
2471         }
2472     }
2473
2474   /* Check whether a curve parameter is available and use that to fill
2475      in missing values.  */
2476   l1 = gcry_sexp_find_token (keyparam, "curve", 5);
2477   if (l1)
2478     {
2479       char *curve;
2480       gcry_mpi_t tmpvalues[N_COMPONENTS];
2481
2482       for (idx = 0; idx < N_COMPONENTS; idx++)
2483         tmpvalues[idx] = NULL;
2484
2485       curve = _gcry_sexp_nth_string (l1, 1);
2486       gcry_sexp_release (l1);
2487       if (!curve)
2488         {
2489           ec = GPG_ERR_INV_OBJ; /* Name missing or out of core. */
2490           goto leave;
2491         }
2492       ec = _gcry_ecc_get_param (curve, tmpvalues);
2493       gcry_free (curve);
2494       if (ec)
2495         goto leave;
2496
2497       for (idx = 0; idx < N_COMPONENTS; idx++)
2498         {
2499           if (!values[idx])
2500             values[idx] = tmpvalues[idx];
2501           else
2502             mpi_free (tmpvalues[idx]);
2503         }
2504     }
2505
2506   /* Check that all parameters are known and normalize all MPIs (that
2507      should not be required but we use an internal function later and
2508      thus we better make 100% sure that they are normalized). */
2509   for (idx = 0; idx < N_COMPONENTS; idx++)
2510     if (!values[idx])
2511       {
2512         ec = GPG_ERR_NO_OBJ;
2513         goto leave;
2514       }
2515     else
2516       _gcry_mpi_normalize (values[idx]);
2517
2518   /* Hash them all.  */
2519   for (idx = 0; idx < N_COMPONENTS; idx++)
2520     {
2521       char buf[30];
2522       unsigned char *rawmpi;
2523       unsigned int rawmpilen;
2524
2525       rawmpi = _gcry_mpi_get_buffer (values[idx], 0, &rawmpilen, NULL);
2526       if (!rawmpi)
2527         {
2528           ec = gpg_err_code_from_syserror ();
2529           goto leave;
2530         }
2531       snprintf (buf, sizeof buf, "(1:%c%u:", names[idx], rawmpilen);
2532       gcry_md_write (md, buf, strlen (buf));
2533       gcry_md_write (md, rawmpi, rawmpilen);
2534       gcry_md_write (md, ")", 1);
2535       gcry_free (rawmpi);
2536     }
2537
2538  leave:
2539   for (idx = 0; idx < N_COMPONENTS; idx++)
2540     _gcry_mpi_release (values[idx]);
2541
2542   return ec;
2543 #undef N_COMPONENTS
2544 }
2545
2546
2547 \f
2548 /*
2549    Low-level API helper functions.
2550  */
2551
2552 /* This is the worker function for gcry_pubkey_get_sexp for ECC
2553    algorithms.  Note that the caller has already stored NULL at
2554    R_SEXP.  */
2555 gpg_err_code_t
2556 _gcry_pk_ecc_get_sexp (gcry_sexp_t *r_sexp, int mode, mpi_ec_t ec)
2557 {
2558   gpg_err_code_t rc;
2559   gcry_mpi_t mpi_G = NULL;
2560   gcry_mpi_t mpi_Q = NULL;
2561
2562   if (!ec->p || !ec->a || !ec->b || !ec->G || !ec->n)
2563     return GPG_ERR_BAD_CRYPT_CTX;
2564
2565   if (mode == GCRY_PK_GET_SECKEY && !ec->d)
2566     return GPG_ERR_NO_SECKEY;
2567
2568   /* Compute the public point if it is missing.  */
2569   if (!ec->Q && ec->d)
2570     ec->Q = _gcry_ecc_compute_public (NULL, ec);
2571
2572   /* Encode G and Q.  */
2573   mpi_G = _gcry_mpi_ec_ec2os (ec->G, ec);
2574   if (!mpi_G)
2575     {
2576       rc = GPG_ERR_BROKEN_PUBKEY;
2577       goto leave;
2578     }
2579   if (!ec->Q)
2580     {
2581       rc = GPG_ERR_BAD_CRYPT_CTX;
2582       goto leave;
2583     }
2584
2585   if (ec->dialect == ECC_DIALECT_ED25519)
2586     {
2587       unsigned char *encpk;
2588       unsigned int encpklen;
2589
2590       rc = _gcry_ecc_eddsa_encodepoint (ec->Q, ec, NULL, NULL,
2591                                         &encpk, &encpklen);
2592       if (rc)
2593         goto leave;
2594       mpi_Q = gcry_mpi_set_opaque (NULL, encpk, encpklen*8);
2595       encpk = NULL;
2596     }
2597   else
2598     {
2599       mpi_Q = _gcry_mpi_ec_ec2os (ec->Q, ec);
2600     }
2601   if (!mpi_Q)
2602     {
2603       rc = GPG_ERR_BROKEN_PUBKEY;
2604       goto leave;
2605     }
2606
2607   /* Fixme: We should return a curve name instead of the parameters if
2608      if know that they match a curve.  */
2609
2610   if (ec->d && (!mode || mode == GCRY_PK_GET_SECKEY))
2611     {
2612       /* Let's return a private key. */
2613       rc = gcry_sexp_build
2614         (r_sexp, NULL,
2615          "(private-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))",
2616          ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q, ec->d);
2617     }
2618   else if (ec->Q)
2619     {
2620       /* Let's return a public key.  */
2621       rc = gcry_sexp_build
2622         (r_sexp, NULL,
2623          "(public-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))",
2624          ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q);
2625     }
2626   else
2627     rc = GPG_ERR_BAD_CRYPT_CTX;
2628
2629  leave:
2630   mpi_free (mpi_Q);
2631   mpi_free (mpi_G);
2632   return rc;
2633 }
2634
2635
2636 \f
2637 /*
2638      Self-test section.
2639  */
2640
2641
2642 static gpg_err_code_t
2643 selftests_ecdsa (selftest_report_func_t report)
2644 {
2645   const char *what;
2646   const char *errtxt;
2647
2648   what = "low-level";
2649   errtxt = NULL; /*selftest ();*/
2650   if (errtxt)
2651     goto failed;
2652
2653   /* FIXME:  need more tests.  */
2654
2655   return 0; /* Succeeded. */
2656
2657  failed:
2658   if (report)
2659     report ("pubkey", GCRY_PK_ECC, what, errtxt);
2660   return GPG_ERR_SELFTEST_FAILED;
2661 }
2662
2663
2664 /* Run a full self-test for ALGO and return 0 on success.  */
2665 static gpg_err_code_t
2666 run_selftests (int algo, int extended, selftest_report_func_t report)
2667 {
2668   (void)extended;
2669
2670   if (algo != GCRY_PK_ECC)
2671     return GPG_ERR_PUBKEY_ALGO;
2672
2673   return selftests_ecdsa (report);
2674 }
2675
2676
2677
2678 \f
2679 gcry_pk_spec_t _gcry_pubkey_spec_ecc =
2680   {
2681     GCRY_PK_ECC, { 0, 0 },
2682     (GCRY_PK_USAGE_SIGN | GCRY_PK_USAGE_ENCR),
2683     "ECC", ecc_names,
2684     "pabgnq", "pabgnqd", "sw", "rs", "pabgnq",
2685     ecc_generate,
2686     ecc_check_secret_key,
2687     ecc_encrypt_raw,
2688     ecc_decrypt_raw,
2689     ecc_sign,
2690     ecc_verify,
2691     ecc_get_nbits,
2692     run_selftests,
2693     compute_keygrip,
2694     _gcry_ecc_get_param,
2695     _gcry_ecc_get_curve,
2696     _gcry_ecc_get_param_sexp
2697   };