pubkey: Move sexp parsing for gcry_pk_getkey to the modules.
[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 /* Registered progress function and its callback value. */
69 static void (*progress_cb) (void *, const char*, int, int, int);
70 static void *progress_cb_data;
71
72
73 #define point_init(a)  _gcry_mpi_point_init ((a))
74 #define point_free(a)  _gcry_mpi_point_free_parts ((a))
75
76 \f
77 /* Local prototypes. */
78 static void test_keys (ECC_secret_key * sk, unsigned int nbits);
79 static int check_secret_key (ECC_secret_key * sk);
80 static gpg_err_code_t sign_ecdsa (gcry_mpi_t input, ECC_secret_key *skey,
81                                   gcry_mpi_t r, gcry_mpi_t s,
82                                   int flags, int hashalgo);
83 static gpg_err_code_t verify_ecdsa (gcry_mpi_t input, ECC_public_key *pkey,
84                                     gcry_mpi_t r, gcry_mpi_t s);
85
86 static gcry_mpi_t gen_y_2 (gcry_mpi_t x, elliptic_curve_t * base);
87
88
89
90 \f
91 void
92 _gcry_register_pk_ecc_progress (void (*cb) (void *, const char *,
93                                             int, int, int),
94                                 void *cb_data)
95 {
96   progress_cb = cb;
97   progress_cb_data = cb_data;
98 }
99
100 /* static void */
101 /* progress (int c) */
102 /* { */
103 /*   if (progress_cb) */
104 /*     progress_cb (progress_cb_data, "pk_ecc", c, 0, 0); */
105 /* } */
106
107
108 \f
109
110 /*
111  * Solve the right side of the Weierstrass equation.
112  */
113 static gcry_mpi_t
114 gen_y_2 (gcry_mpi_t x, elliptic_curve_t *base)
115 {
116   gcry_mpi_t three, x_3, axb, y;
117
118   three = mpi_alloc_set_ui (3);
119   x_3 = mpi_new (0);
120   axb = mpi_new (0);
121   y   = mpi_new (0);
122
123   mpi_powm (x_3, x, three, base->p);
124   mpi_mulm (axb, base->a, x, base->p);
125   mpi_addm (axb, axb, base->b, base->p);
126   mpi_addm (y, x_3, axb, base->p);
127
128   mpi_free (x_3);
129   mpi_free (axb);
130   mpi_free (three);
131   return y; /* The quadratic value of the coordinate if it exist. */
132 }
133
134
135 /* Standard version of the key generation.  */
136 static gpg_err_code_t
137 nist_generate_key (ECC_secret_key *sk, elliptic_curve_t *E, mpi_ec_t ctx,
138                    gcry_random_level_t random_level, unsigned int nbits)
139 {
140   mpi_point_struct Q;
141
142   point_init (&Q);
143
144   /* Generate a secret.  */
145   sk->d = _gcry_dsa_gen_k (E->n, random_level);
146
147   /* Compute Q.  */
148   _gcry_mpi_ec_mul_point (&Q, sk->d, &E->G, ctx);
149
150   /* Copy the stuff to the key structures. */
151   sk->E.model = E->model;
152   sk->E.dialect = E->dialect;
153   sk->E.p = mpi_copy (E->p);
154   sk->E.a = mpi_copy (E->a);
155   sk->E.b = mpi_copy (E->b);
156   point_init (&sk->E.G);
157   point_set (&sk->E.G, &E->G);
158   sk->E.n = mpi_copy (E->n);
159   point_init (&sk->Q);
160
161   /* We want the Q=(x,y) be a "compliant key" in terms of the
162    * http://tools.ietf.org/html/draft-jivsov-ecc-compact, which simply
163    * means that we choose either Q=(x,y) or -Q=(x,p-y) such that we
164    * end up with the min(y,p-y) as the y coordinate.  Such a public
165    * key allows the most efficient compression: y can simply be
166    * dropped because we know that it's a minimum of the two
167    * possibilities without any loss of security.  */
168   {
169     gcry_mpi_t x, y, p_y;
170     const unsigned int pbits = mpi_get_nbits (E->p);
171
172     x = mpi_new (pbits);
173     y = mpi_new (pbits);
174     p_y = mpi_new (pbits);
175
176     if (_gcry_mpi_ec_get_affine (x, y, &Q, ctx))
177       log_fatal ("ecgen: Failed to get affine coordinates for %s\n", "Q");
178
179     mpi_sub (p_y, E->p, y);     /* p_y = p - y */
180
181     if (mpi_cmp (p_y, y) < 0)   /* p - y < p */
182       {
183         /* We need to end up with -Q; this assures that new Q's y is
184            the smallest one */
185         mpi_sub (sk->d, E->n, sk->d);   /* d = order - d */
186         gcry_mpi_point_snatch_set (&sk->Q, x, p_y, mpi_alloc_set_ui (1));
187
188       if (DBG_CIPHER)
189         log_debug ("ecgen converted Q to a compliant point\n");
190       }
191     else /* p - y >= p */
192       {
193         /* No change is needed exactly 50% of the time: just copy. */
194         point_set (&sk->Q, &Q);
195         if (DBG_CIPHER)
196           log_debug ("ecgen didn't need to convert Q to a compliant point\n");
197
198         mpi_free (p_y);
199         mpi_free (x);
200       }
201     mpi_free (y);
202   }
203
204   /* Now we can test our keys (this should never fail!).  */
205   test_keys (sk, nbits - 64);
206
207   return 0;
208 }
209
210
211 /*
212  * To verify correct skey it use a random information.
213  * First, encrypt and decrypt this dummy value,
214  * test if the information is recuperated.
215  * Second, test with the sign and verify functions.
216  */
217 static void
218 test_keys (ECC_secret_key *sk, unsigned int nbits)
219 {
220   ECC_public_key pk;
221   gcry_mpi_t test = mpi_new (nbits);
222   mpi_point_struct R_;
223   gcry_mpi_t c = mpi_new (nbits);
224   gcry_mpi_t out = mpi_new (nbits);
225   gcry_mpi_t r = mpi_new (nbits);
226   gcry_mpi_t s = mpi_new (nbits);
227
228   if (DBG_CIPHER)
229     log_debug ("Testing key.\n");
230
231   point_init (&R_);
232
233   pk.E = _gcry_ecc_curve_copy (sk->E);
234   point_init (&pk.Q);
235   point_set (&pk.Q, &sk->Q);
236
237   gcry_mpi_randomize (test, nbits, GCRY_WEAK_RANDOM);
238
239   if (sign_ecdsa (test, sk, r, s, 0, 0) )
240     log_fatal ("ECDSA operation: sign failed\n");
241
242   if (verify_ecdsa (test, &pk, r, s))
243     {
244       log_fatal ("ECDSA operation: sign, verify failed\n");
245     }
246
247   if (DBG_CIPHER)
248     log_debug ("ECDSA operation: sign, verify ok.\n");
249
250   point_free (&pk.Q);
251   _gcry_ecc_curve_free (&pk.E);
252
253   point_free (&R_);
254   mpi_free (s);
255   mpi_free (r);
256   mpi_free (out);
257   mpi_free (c);
258   mpi_free (test);
259 }
260
261
262 /*
263  * To check the validity of the value, recalculate the correspondence
264  * between the public value and the secret one.
265  */
266 static int
267 check_secret_key (ECC_secret_key * sk)
268 {
269   int rc = 1;
270   mpi_point_struct Q;
271   gcry_mpi_t y_2, y2;
272   gcry_mpi_t x1, x2;
273   mpi_ec_t ctx = NULL;
274
275   point_init (&Q);
276
277   /* ?primarity test of 'p' */
278   /*  (...) //!! */
279   /* G in E(F_p) */
280   y_2 = gen_y_2 (sk->E.G.x, &sk->E);   /*  y^2=x^3+a*x+b */
281   y2 = mpi_alloc (0);
282   x1 = mpi_alloc (0);
283   x2 = mpi_alloc (0);
284   mpi_mulm (y2, sk->E.G.y, sk->E.G.y, sk->E.p);      /*  y^2=y*y */
285   if (mpi_cmp (y_2, y2))
286     {
287       if (DBG_CIPHER)
288         log_debug ("Bad check: Point 'G' does not belong to curve 'E'!\n");
289       goto leave;
290     }
291   /* G != PaI */
292   if (!mpi_cmp_ui (sk->E.G.z, 0))
293     {
294       if (DBG_CIPHER)
295         log_debug ("Bad check: 'G' cannot be Point at Infinity!\n");
296       goto leave;
297     }
298
299   ctx = _gcry_mpi_ec_p_internal_new (sk->E.model, sk->E.dialect,
300                                      sk->E.p, sk->E.a, sk->E.b);
301
302   _gcry_mpi_ec_mul_point (&Q, sk->E.n, &sk->E.G, ctx);
303   if (mpi_cmp_ui (Q.z, 0))
304     {
305       if (DBG_CIPHER)
306         log_debug ("check_secret_key: E is not a curve of order n\n");
307       goto leave;
308     }
309   /* pubkey cannot be PaI */
310   if (!mpi_cmp_ui (sk->Q.z, 0))
311     {
312       if (DBG_CIPHER)
313         log_debug ("Bad check: Q can not be a Point at Infinity!\n");
314       goto leave;
315     }
316   /* pubkey = [d]G over E */
317   _gcry_mpi_ec_mul_point (&Q, sk->d, &sk->E.G, ctx);
318
319   if (_gcry_mpi_ec_get_affine (x1, y_2, &Q, ctx))
320     {
321       if (DBG_CIPHER)
322         log_debug ("Bad check: Q can not be a Point at Infinity!\n");
323       goto leave;
324     }
325
326   /* Fast path for loaded secret keys - Q is already in affine coordinates */
327   if (!mpi_cmp_ui (sk->Q.z, 1))
328     {
329       if (mpi_cmp (x1, sk->Q.x) || mpi_cmp (y_2, sk->Q.y))
330         {
331           if (DBG_CIPHER)
332             log_debug
333               ("Bad check: There is NO correspondence between 'd' and 'Q'!\n");
334           goto leave;
335         }
336     }
337   else
338     {
339       if (_gcry_mpi_ec_get_affine (x2, y2, &sk->Q, ctx))
340         {
341           if (DBG_CIPHER)
342             log_debug ("Bad check: Q can not be a Point at Infinity!\n");
343           goto leave;
344         }
345
346       if (mpi_cmp (x1, x2) || mpi_cmp (y_2, y2))
347         {
348           if (DBG_CIPHER)
349             log_debug
350               ("Bad check: There is NO correspondence between 'd' and 'Q'!\n");
351           goto leave;
352         }
353     }
354   rc = 0; /* Okay.  */
355
356  leave:
357   _gcry_mpi_ec_free (ctx);
358   mpi_free (x2);
359   mpi_free (x1);
360   mpi_free (y2);
361   mpi_free (y_2);
362   point_free (&Q);
363   return rc;
364 }
365
366
367 /* Compute an ECDSA signature.
368  * Return the signature struct (r,s) from the message hash.  The caller
369  * must have allocated R and S.
370  */
371 static gpg_err_code_t
372 sign_ecdsa (gcry_mpi_t input, ECC_secret_key *skey, gcry_mpi_t r, gcry_mpi_t s,
373             int flags, int hashalgo)
374 {
375   gpg_err_code_t err = 0;
376   int extraloops = 0;
377   gcry_mpi_t k, dr, sum, k_1, x;
378   mpi_point_struct I;
379   gcry_mpi_t hash;
380   const void *abuf;
381   unsigned int abits, qbits;
382   mpi_ec_t ctx;
383
384   if (DBG_CIPHER)
385     log_mpidump ("ecdsa sign hash  ", input );
386
387   qbits = mpi_get_nbits (skey->E.n);
388
389   /* Convert the INPUT into an MPI if needed.  */
390   if (mpi_is_opaque (input))
391     {
392       abuf = gcry_mpi_get_opaque (input, &abits);
393       err = gpg_err_code (gcry_mpi_scan (&hash, GCRYMPI_FMT_USG,
394                                          abuf, (abits+7)/8, NULL));
395       if (err)
396         return err;
397       if (abits > qbits)
398         gcry_mpi_rshift (hash, hash, abits - qbits);
399     }
400   else
401     hash = input;
402
403
404   k = NULL;
405   dr = mpi_alloc (0);
406   sum = mpi_alloc (0);
407   k_1 = mpi_alloc (0);
408   x = mpi_alloc (0);
409   point_init (&I);
410
411   ctx = _gcry_mpi_ec_p_internal_new (skey->E.model, skey->E.dialect,
412                                      skey->E.p, skey->E.a, skey->E.b);
413
414   /* Two loops to avoid R or S are zero.  This is more of a joke than
415      a real demand because the probability of them being zero is less
416      than any hardware failure.  Some specs however require it.  */
417   do
418     {
419       do
420         {
421           mpi_free (k);
422           k = NULL;
423           if ((flags & PUBKEY_FLAG_RFC6979) && hashalgo)
424             {
425               /* Use Pornin's method for deterministic DSA.  If this
426                  flag is set, it is expected that HASH is an opaque
427                  MPI with the to be signed hash.  That hash is also
428                  used as h1 from 3.2.a.  */
429               if (!mpi_is_opaque (input))
430                 {
431                   err = GPG_ERR_CONFLICT;
432                   goto leave;
433                 }
434
435               abuf = gcry_mpi_get_opaque (input, &abits);
436               err = _gcry_dsa_gen_rfc6979_k (&k, skey->E.n, skey->d,
437                                              abuf, (abits+7)/8,
438                                              hashalgo, extraloops);
439               if (err)
440                 goto leave;
441               extraloops++;
442             }
443           else
444             k = _gcry_dsa_gen_k (skey->E.n, GCRY_STRONG_RANDOM);
445
446           _gcry_mpi_ec_mul_point (&I, k, &skey->E.G, ctx);
447           if (_gcry_mpi_ec_get_affine (x, NULL, &I, ctx))
448             {
449               if (DBG_CIPHER)
450                 log_debug ("ecc sign: Failed to get affine coordinates\n");
451               err = GPG_ERR_BAD_SIGNATURE;
452               goto leave;
453             }
454           mpi_mod (r, x, skey->E.n);  /* r = x mod n */
455         }
456       while (!mpi_cmp_ui (r, 0));
457
458       mpi_mulm (dr, skey->d, r, skey->E.n); /* dr = d*r mod n  */
459       mpi_addm (sum, hash, dr, skey->E.n);  /* sum = hash + (d*r) mod n  */
460       mpi_invm (k_1, k, skey->E.n);         /* k_1 = k^(-1) mod n  */
461       mpi_mulm (s, k_1, sum, skey->E.n);    /* s = k^(-1)*(hash+(d*r)) mod n */
462     }
463   while (!mpi_cmp_ui (s, 0));
464
465   if (DBG_CIPHER)
466     {
467       log_mpidump ("ecdsa sign result r ", r);
468       log_mpidump ("ecdsa sign result s ", s);
469     }
470
471  leave:
472   _gcry_mpi_ec_free (ctx);
473   point_free (&I);
474   mpi_free (x);
475   mpi_free (k_1);
476   mpi_free (sum);
477   mpi_free (dr);
478   mpi_free (k);
479
480   if (hash != input)
481     mpi_free (hash);
482
483   return err;
484 }
485
486
487 /* Verify an ECDSA signature.
488  * Check if R and S verifies INPUT.
489  */
490 static gpg_err_code_t
491 verify_ecdsa (gcry_mpi_t input, ECC_public_key *pkey,
492               gcry_mpi_t r, gcry_mpi_t s)
493 {
494   gpg_err_code_t err = 0;
495   gcry_mpi_t h, h1, h2, x;
496   mpi_point_struct Q, Q1, Q2;
497   mpi_ec_t ctx;
498
499   if( !(mpi_cmp_ui (r, 0) > 0 && mpi_cmp (r, pkey->E.n) < 0) )
500     return GPG_ERR_BAD_SIGNATURE; /* Assertion  0 < r < n  failed.  */
501   if( !(mpi_cmp_ui (s, 0) > 0 && mpi_cmp (s, pkey->E.n) < 0) )
502     return GPG_ERR_BAD_SIGNATURE; /* Assertion  0 < s < n  failed.  */
503
504   h  = mpi_alloc (0);
505   h1 = mpi_alloc (0);
506   h2 = mpi_alloc (0);
507   x = mpi_alloc (0);
508   point_init (&Q);
509   point_init (&Q1);
510   point_init (&Q2);
511
512   ctx = _gcry_mpi_ec_p_internal_new (pkey->E.model, pkey->E.dialect,
513                                      pkey->E.p, pkey->E.a, pkey->E.b);
514
515   /* h  = s^(-1) (mod n) */
516   mpi_invm (h, s, pkey->E.n);
517   /* h1 = hash * s^(-1) (mod n) */
518   mpi_mulm (h1, input, h, pkey->E.n);
519   /* Q1 = [ hash * s^(-1) ]G  */
520   _gcry_mpi_ec_mul_point (&Q1, h1, &pkey->E.G, ctx);
521   /* h2 = r * s^(-1) (mod n) */
522   mpi_mulm (h2, r, h, pkey->E.n);
523   /* Q2 = [ r * s^(-1) ]Q */
524   _gcry_mpi_ec_mul_point (&Q2, h2, &pkey->Q, ctx);
525   /* Q  = ([hash * s^(-1)]G) + ([r * s^(-1)]Q) */
526   _gcry_mpi_ec_add_points (&Q, &Q1, &Q2, ctx);
527
528   if (!mpi_cmp_ui (Q.z, 0))
529     {
530       if (DBG_CIPHER)
531           log_debug ("ecc verify: Rejected\n");
532       err = GPG_ERR_BAD_SIGNATURE;
533       goto leave;
534     }
535   if (_gcry_mpi_ec_get_affine (x, NULL, &Q, ctx))
536     {
537       if (DBG_CIPHER)
538         log_debug ("ecc verify: Failed to get affine coordinates\n");
539       err = GPG_ERR_BAD_SIGNATURE;
540       goto leave;
541     }
542   mpi_mod (x, x, pkey->E.n); /* x = x mod E_n */
543   if (mpi_cmp (x, r))   /* x != r */
544     {
545       if (DBG_CIPHER)
546         {
547           log_mpidump ("     x", x);
548           log_mpidump ("     r", r);
549           log_mpidump ("     s", s);
550           log_debug ("ecc verify: Not verified\n");
551         }
552       err = GPG_ERR_BAD_SIGNATURE;
553       goto leave;
554     }
555   if (DBG_CIPHER)
556     log_debug ("ecc verify: Accepted\n");
557
558  leave:
559   _gcry_mpi_ec_free (ctx);
560   point_free (&Q2);
561   point_free (&Q1);
562   point_free (&Q);
563   mpi_free (x);
564   mpi_free (h2);
565   mpi_free (h1);
566   mpi_free (h);
567   return err;
568 }
569
570
571 \f
572 static void
573 reverse_buffer (unsigned char *buffer, unsigned int length)
574 {
575   unsigned int tmp, i;
576
577   for (i=0; i < length/2; i++)
578     {
579       tmp = buffer[i];
580       buffer[i] = buffer[length-1-i];
581       buffer[length-1-i] = tmp;
582     }
583 }
584
585
586 /* Encode MPI using the EdDSA scheme.  MINLEN specifies the required
587    length of the buffer in bytes.  On success 0 is returned an a
588    malloced buffer with the encoded point is stored at R_BUFFER; the
589    length of this buffer is stored at R_BUFLEN.  */
590 static gpg_err_code_t
591 eddsa_encodempi (gcry_mpi_t mpi, unsigned int minlen,
592                  unsigned char **r_buffer, unsigned int *r_buflen)
593 {
594   unsigned char *rawmpi;
595   unsigned int rawmpilen;
596
597   rawmpi = _gcry_mpi_get_buffer (mpi, minlen, &rawmpilen, NULL);
598   if (!rawmpi)
599     return gpg_err_code_from_syserror ();
600
601   *r_buffer = rawmpi;
602   *r_buflen = rawmpilen;
603   return 0;
604 }
605
606
607 /* Encode (X,Y) using the EdDSA scheme.  MINLEN is the required length
608    in bytes for the result.  On success 0 is returned and a malloced
609    buffer with the encoded point is stored at R_BUFFER; the length of
610    this buffer is stored at R_BUFLEN.  */
611 static gpg_err_code_t
612 eddsa_encode_x_y (gcry_mpi_t x, gcry_mpi_t y, unsigned int minlen,
613                   unsigned char **r_buffer, unsigned int *r_buflen)
614 {
615   unsigned char *rawmpi;
616   unsigned int rawmpilen;
617
618   rawmpi = _gcry_mpi_get_buffer (y, minlen, &rawmpilen, NULL);
619   if (!rawmpi)
620     return gpg_err_code_from_syserror ();
621   if (mpi_test_bit (x, 0) && rawmpilen)
622     rawmpi[rawmpilen - 1] |= 0x80;  /* Set sign bit.  */
623
624   *r_buffer = rawmpi;
625   *r_buflen = rawmpilen;
626   return 0;
627 }
628
629 /* Encode POINT using the EdDSA scheme.  X and Y are either scratch
630    variables supplied by the caller or NULL.  CTX is the usual
631    context.  On success 0 is returned and a malloced buffer with the
632    encoded point is stored at R_BUFFER; the length of this buffer is
633    stored at R_BUFLEN.  */
634 gpg_err_code_t
635 _gcry_ecc_eddsa_encodepoint (mpi_point_t point, mpi_ec_t ec,
636                              gcry_mpi_t x_in, gcry_mpi_t y_in,
637                              unsigned char **r_buffer, unsigned int *r_buflen)
638 {
639   gpg_err_code_t rc;
640   gcry_mpi_t x, y;
641
642   x = x_in? x_in : mpi_new (0);
643   y = y_in? y_in : mpi_new (0);
644
645   if (_gcry_mpi_ec_get_affine (x, y, point, ec))
646     {
647       log_error ("eddsa_encodepoint: Failed to get affine coordinates\n");
648       rc = GPG_ERR_INTERNAL;
649     }
650   else
651     rc = eddsa_encode_x_y (x, y, ec->nbits/8, r_buffer, r_buflen);
652
653   if (!x_in)
654     mpi_free (x);
655   if (!y_in)
656     mpi_free (y);
657   return rc;
658 }
659
660
661 /* Decode the EdDSA style encoded PK and set it into RESULT.  CTX is
662    the usual curve context.  If R_ENCPK is not NULL, the encoded PK is
663    stored at that address; this is a new copy to be released by the
664    caller.  In contrast to the supplied PK, this is not an MPI and
665    thus guarnateed to be properly padded.  R_ENCPKLEN received the
666    length of that encoded key.  */
667 gpg_err_code_t
668 _gcry_ecc_eddsa_decodepoint (gcry_mpi_t pk, mpi_ec_t ctx, mpi_point_t result,
669                              unsigned char **r_encpk, unsigned int *r_encpklen)
670 {
671   gpg_err_code_t rc;
672   unsigned char *rawmpi;
673   unsigned int rawmpilen;
674   gcry_mpi_t yy, t, x, p1, p2, p3;
675   int sign;
676
677   if (mpi_is_opaque (pk))
678     {
679       const unsigned char *buf;
680
681       buf = gcry_mpi_get_opaque (pk, &rawmpilen);
682       if (!buf)
683         return GPG_ERR_INV_OBJ;
684       rawmpilen = (rawmpilen + 7)/8;
685
686       /* First check whether the public key has been given in standard
687          uncompressed format.  No need to recover x in this case.
688          Detection is easy: The size of the buffer will be odd and the
689          first byte be 0x04.  */
690       if (rawmpilen > 1 && buf[0] == 0x04 && (rawmpilen%2))
691         {
692           gcry_mpi_t y;
693
694           rc = gcry_mpi_scan (&x, GCRYMPI_FMT_STD,
695                               buf+1, (rawmpilen-1)/2, NULL);
696           if (rc)
697             return rc;
698           rc = gcry_mpi_scan (&y, GCRYMPI_FMT_STD,
699                               buf+1+(rawmpilen-1)/2, (rawmpilen-1)/2, NULL);
700           if (rc)
701             {
702               mpi_free (x);
703               return rc;
704             }
705
706           if (r_encpk)
707             {
708               rc = eddsa_encode_x_y (x, y, ctx->nbits/8, r_encpk, r_encpklen);
709               if (rc)
710                 {
711                   mpi_free (x);
712                   mpi_free (y);
713                   return rc;
714                 }
715             }
716           mpi_snatch (result->x, x);
717           mpi_snatch (result->y, y);
718           mpi_set_ui (result->z, 1);
719           return 0;
720         }
721
722       /* EdDSA compressed point.  */
723       rawmpi = gcry_malloc (rawmpilen? rawmpilen:1);
724       if (!rawmpi)
725         return gpg_err_code_from_syserror ();
726       memcpy (rawmpi, buf, rawmpilen);
727       reverse_buffer (rawmpi, rawmpilen);
728     }
729   else
730     {
731       /* Note: Without using an opaque MPI it is not reliable possible
732          to find out whether the public key has been given in
733          uncompressed format.  Thus we expect EdDSA format here.  */
734       rawmpi = _gcry_mpi_get_buffer (pk, ctx->nbits/8, &rawmpilen, NULL);
735       if (!rawmpi)
736         return gpg_err_code_from_syserror ();
737     }
738
739   if (rawmpilen)
740     {
741       sign = !!(rawmpi[0] & 0x80);
742       rawmpi[0] &= 0x7f;
743     }
744   else
745     sign = 0;
746   _gcry_mpi_set_buffer (result->y, rawmpi, rawmpilen, 0);
747   if (r_encpk)
748     {
749       /* Revert to little endian.  */
750       if (sign && rawmpilen)
751         rawmpi[0] |= 0x80;
752       reverse_buffer (rawmpi, rawmpilen);
753       *r_encpk = rawmpi;
754       if (r_encpklen)
755         *r_encpklen = rawmpilen;
756     }
757   else
758     gcry_free (rawmpi);
759
760   /* Now recover X.  */
761   /* t = (y^2-1) · ((b*y^2+1)^{p-2} mod p) */
762   x = mpi_new (0);
763   yy = mpi_new (0);
764   mpi_mul (yy, result->y, result->y);
765   t = mpi_copy (yy);
766   mpi_mul (t, t, ctx->b);
767   mpi_add_ui (t, t, 1);
768   p2 = mpi_copy (ctx->p);
769   mpi_sub_ui (p2, p2, 2);
770   mpi_powm (t, t, p2, ctx->p);
771
772   mpi_sub_ui (yy, yy, 1);
773   mpi_mul (t, yy, t);
774
775   /* x = t^{(p+3)/8} mod p */
776   p3 = mpi_copy (ctx->p);
777   mpi_add_ui (p3, p3, 3);
778   mpi_fdiv_q (p3, p3, mpi_const (MPI_C_EIGHT));
779   mpi_powm (x, t, p3, ctx->p);
780
781   /* (x^2 - t) % p != 0 ? x = (x*(2^{(p-1)/4} mod p)) % p */
782   mpi_mul (yy, x, x);
783   mpi_subm (yy, yy, t, ctx->p);
784   if (mpi_cmp_ui (yy, 0))
785     {
786       p1 = mpi_copy (ctx->p);
787       mpi_sub_ui (p1, p1, 1);
788       mpi_fdiv_q (p1, p1, mpi_const (MPI_C_FOUR));
789       mpi_powm (yy, mpi_const (MPI_C_TWO), p1, ctx->p);
790       mpi_mulm (x, x, yy, ctx->p);
791     }
792   else
793     p1 = NULL;
794
795   /* is_odd(x) ? x = p-x */
796   if (mpi_test_bit (x, 0))
797     mpi_sub (x, ctx->p, x);
798
799   /* lowbit(x) != highbit(input) ?  x = p-x */
800   if (mpi_test_bit (x, 0) != sign)
801     mpi_sub (x, ctx->p, x);
802
803   mpi_set (result->x, x);
804   mpi_set_ui (result->z, 1);
805
806   gcry_mpi_release (x);
807   gcry_mpi_release (yy);
808   gcry_mpi_release (t);
809   gcry_mpi_release (p3);
810   gcry_mpi_release (p2);
811   gcry_mpi_release (p1);
812
813   return 0;
814 }
815
816
817 /* Ed25519 version of the key generation.  */
818 static gpg_err_code_t
819 eddsa_generate_key (ECC_secret_key *sk, elliptic_curve_t *E, mpi_ec_t ctx,
820                     gcry_random_level_t random_level)
821 {
822   gpg_err_code_t rc;
823   int b = 256/8;             /* The only size we currently support.  */
824   gcry_mpi_t a, x, y;
825   mpi_point_struct Q;
826   char *dbuf;
827   size_t dlen;
828   gcry_buffer_t hvec[1];
829   unsigned char *hash_d = NULL;
830
831   point_init (&Q);
832   memset (hvec, 0, sizeof hvec);
833
834   a = mpi_snew (0);
835   x = mpi_new (0);
836   y = mpi_new (0);
837
838   /* Generate a secret.  */
839   hash_d = gcry_malloc_secure (2*b);
840   if (!hash_d)
841     {
842       rc = gpg_error_from_syserror ();
843       goto leave;
844     }
845   dlen = b;
846   dbuf = gcry_random_bytes_secure (dlen, random_level);
847
848   /* Compute the A value.  */
849   hvec[0].data = dbuf;
850   hvec[0].len = dlen;
851   rc = _gcry_md_hash_buffers (GCRY_MD_SHA512, 0, hash_d, hvec, 1);
852   if (rc)
853     goto leave;
854   sk->d = _gcry_mpi_set_opaque (NULL, dbuf, dlen*8);
855   dbuf = NULL;
856   reverse_buffer (hash_d, 32);  /* Only the first half of the hash.  */
857   hash_d[0] = (hash_d[0] & 0x7f) | 0x40;
858   hash_d[31] &= 0xf8;
859   _gcry_mpi_set_buffer (a, hash_d, 32, 0);
860   gcry_free (hash_d); hash_d = NULL;
861   /* log_printmpi ("ecgen         a", a); */
862
863   /* Compute Q.  */
864   _gcry_mpi_ec_mul_point (&Q, a, &E->G, ctx);
865   if (DBG_CIPHER)
866     log_printpnt ("ecgen      pk", &Q, ctx);
867
868   /* Copy the stuff to the key structures. */
869   sk->E.model = E->model;
870   sk->E.dialect = E->dialect;
871   sk->E.p = mpi_copy (E->p);
872   sk->E.a = mpi_copy (E->a);
873   sk->E.b = mpi_copy (E->b);
874   point_init (&sk->E.G);
875   point_set (&sk->E.G, &E->G);
876   sk->E.n = mpi_copy (E->n);
877   point_init (&sk->Q);
878   point_set (&sk->Q, &Q);
879
880  leave:
881   gcry_mpi_release (a);
882   gcry_mpi_release (x);
883   gcry_mpi_release (y);
884   gcry_free (hash_d);
885   return rc;
886 }
887
888
889 /* Compute an EdDSA signature. See:
890  *   [ed25519] 23pp. (PDF) Daniel J. Bernstein, Niels Duif, Tanja
891  *   Lange, Peter Schwabe, Bo-Yin Yang. High-speed high-security
892  *   signatures.  Journal of Cryptographic Engineering 2 (2012), 77-89.
893  *   Document ID: a1a62a2f76d23f65d622484ddd09caf8.
894  *   URL: http://cr.yp.to/papers.html#ed25519. Date: 2011.09.26.
895  *
896  * Despite that this function requires the specification of a hash
897  * algorithm, we only support what has been specified by the paper.
898  * This may change in the future.  Note that we don't check the used
899  * curve; the user is responsible to use Ed25519.
900  *
901  * Return the signature struct (r,s) from the message hash.  The caller
902  * must have allocated R_R and S.
903  */
904 static gpg_err_code_t
905 sign_eddsa (gcry_mpi_t input, ECC_secret_key *skey,
906             gcry_mpi_t r_r, gcry_mpi_t s, int hashalgo, gcry_mpi_t pk)
907 {
908   int rc;
909   mpi_ec_t ctx = NULL;
910   int b;
911   unsigned int tmp;
912   unsigned char *digest;
913   gcry_buffer_t hvec[3];
914   const void *mbuf;
915   size_t mlen;
916   unsigned char *rawmpi = NULL;
917   unsigned int rawmpilen;
918   unsigned char *encpk = NULL; /* Encoded public key.  */
919   unsigned int encpklen;
920   mpi_point_struct I;          /* Intermediate value.  */
921   mpi_point_struct Q;          /* Public key.  */
922   gcry_mpi_t a, x, y, r;
923
924   memset (hvec, 0, sizeof hvec);
925
926   if (!mpi_is_opaque (input))
927     return GPG_ERR_INV_DATA;
928   if (hashalgo != GCRY_MD_SHA512)
929     return GPG_ERR_DIGEST_ALGO;
930
931   /* Initialize some helpers.  */
932   point_init (&I);
933   point_init (&Q);
934   a = mpi_snew (0);
935   x = mpi_new (0);
936   y = mpi_new (0);
937   r = mpi_new (0);
938   ctx = _gcry_mpi_ec_p_internal_new (skey->E.model, skey->E.dialect,
939                                      skey->E.p, skey->E.a, skey->E.b);
940   b = (ctx->nbits+7)/8;
941   if (b != 256/8)
942     return GPG_ERR_INTERNAL; /* We only support 256 bit. */
943
944   digest = gcry_calloc_secure (2, b);
945   if (!digest)
946     {
947       rc = gpg_err_code_from_syserror ();
948       goto leave;
949     }
950
951   /* Hash the secret key.  We clear DIGEST so we can use it as input
952      to left pad the key with zeroes for hashing.  */
953   rawmpi = _gcry_mpi_get_buffer (skey->d, 0, &rawmpilen, NULL);
954   if (!rawmpi)
955     {
956       rc = gpg_err_code_from_syserror ();
957       goto leave;
958     }
959   hvec[0].data = digest;
960   hvec[0].off = 0;
961   hvec[0].len = b > rawmpilen? b - rawmpilen : 0;
962   hvec[1].data = rawmpi;
963   hvec[1].off = 0;
964   hvec[1].len = rawmpilen;
965   rc = _gcry_md_hash_buffers (hashalgo, 0, digest, hvec, 2);
966   gcry_free (rawmpi); rawmpi = NULL;
967   if (rc)
968     goto leave;
969
970   /* Compute the A value (this modifies DIGEST).  */
971   reverse_buffer (digest, 32);  /* Only the first half of the hash.  */
972   digest[0] = (digest[0] & 0x7f) | 0x40;
973   digest[31] &= 0xf8;
974   _gcry_mpi_set_buffer (a, digest, 32, 0);
975
976   /* Compute the public key if it has not been supplied as optional
977      parameter.  */
978   if (pk)
979     {
980       rc = _gcry_ecc_eddsa_decodepoint (pk, ctx, &Q,  &encpk, &encpklen);
981       if (rc)
982         goto leave;
983       if (DBG_CIPHER)
984         log_printhex ("* e_pk", encpk, encpklen);
985       if (!_gcry_mpi_ec_curve_point (&Q, ctx))
986         {
987           rc = GPG_ERR_BROKEN_PUBKEY;
988           goto leave;
989         }
990     }
991   else
992     {
993       _gcry_mpi_ec_mul_point (&Q, a, &skey->E.G, ctx);
994       rc = _gcry_ecc_eddsa_encodepoint (&Q, ctx, x, y, &encpk, &encpklen);
995       if (rc)
996         goto leave;
997       if (DBG_CIPHER)
998         log_printhex ("  e_pk", encpk, encpklen);
999     }
1000
1001   /* Compute R.  */
1002   mbuf = gcry_mpi_get_opaque (input, &tmp);
1003   mlen = (tmp +7)/8;
1004   if (DBG_CIPHER)
1005     log_printhex ("     m", mbuf, mlen);
1006
1007   hvec[0].data = digest;
1008   hvec[0].off  = 32;
1009   hvec[0].len  = 32;
1010   hvec[1].data = (char*)mbuf;
1011   hvec[1].len  = mlen;
1012   rc = _gcry_md_hash_buffers (hashalgo, 0, digest, hvec, 2);
1013   if (rc)
1014     goto leave;
1015   reverse_buffer (digest, 64);
1016   if (DBG_CIPHER)
1017     log_printhex ("     r", digest, 64);
1018   _gcry_mpi_set_buffer (r, digest, 64, 0);
1019   _gcry_mpi_ec_mul_point (&I, r, &skey->E.G, ctx);
1020   if (DBG_CIPHER)
1021     log_printpnt ("   r", &I, ctx);
1022
1023   /* Convert R into affine coordinates and apply encoding.  */
1024   rc = _gcry_ecc_eddsa_encodepoint (&I, ctx, x, y, &rawmpi, &rawmpilen);
1025   if (rc)
1026     goto leave;
1027   if (DBG_CIPHER)
1028     log_printhex ("   e_r", rawmpi, rawmpilen);
1029
1030   /* S = r + a * H(encodepoint(R) + encodepoint(pk) + m) mod n  */
1031   hvec[0].data = rawmpi;  /* (this is R) */
1032   hvec[0].off  = 0;
1033   hvec[0].len  = rawmpilen;
1034   hvec[1].data = encpk;
1035   hvec[1].off  = 0;
1036   hvec[1].len  = encpklen;
1037   hvec[2].data = (char*)mbuf;
1038   hvec[2].off  = 0;
1039   hvec[2].len  = mlen;
1040   rc = _gcry_md_hash_buffers (hashalgo, 0, digest, hvec, 3);
1041   if (rc)
1042     goto leave;
1043
1044   /* No more need for RAWMPI thus we now transfer it to R_R.  */
1045   gcry_mpi_set_opaque (r_r, rawmpi, rawmpilen*8);
1046   rawmpi = NULL;
1047
1048   reverse_buffer (digest, 64);
1049   if (DBG_CIPHER)
1050     log_printhex (" H(R+)", digest, 64);
1051   _gcry_mpi_set_buffer (s, digest, 64, 0);
1052   mpi_mulm (s, s, a, skey->E.n);
1053   mpi_addm (s, s, r, skey->E.n);
1054   rc = eddsa_encodempi (s, b, &rawmpi, &rawmpilen);
1055   if (rc)
1056     goto leave;
1057   if (DBG_CIPHER)
1058     log_printhex ("   e_s", rawmpi, rawmpilen);
1059   gcry_mpi_set_opaque (s, rawmpi, rawmpilen*8);
1060   rawmpi = NULL;
1061
1062   rc = 0;
1063
1064  leave:
1065   gcry_mpi_release (a);
1066   gcry_mpi_release (x);
1067   gcry_mpi_release (y);
1068   gcry_mpi_release (r);
1069   gcry_free (digest);
1070   _gcry_mpi_ec_free (ctx);
1071   point_free (&I);
1072   point_free (&Q);
1073   gcry_free (encpk);
1074   gcry_free (rawmpi);
1075   return rc;
1076 }
1077
1078
1079 /* Verify an EdDSA signature.  See sign_eddsa for the reference.
1080  * Check if R_IN and S_IN verifies INPUT.  PKEY has the curve
1081  * parameters and PK is the EdDSA style encoded public key.
1082  */
1083 static gpg_err_code_t
1084 verify_eddsa (gcry_mpi_t input, ECC_public_key *pkey,
1085               gcry_mpi_t r_in, gcry_mpi_t s_in, int hashalgo, gcry_mpi_t pk)
1086 {
1087   int rc;
1088   mpi_ec_t ctx = NULL;
1089   int b;
1090   unsigned int tmp;
1091   mpi_point_struct Q;          /* Public key.  */
1092   unsigned char *encpk = NULL; /* Encoded public key.  */
1093   unsigned int encpklen;
1094   const void *mbuf, *rbuf;
1095   unsigned char *tbuf = NULL;
1096   size_t mlen, rlen;
1097   unsigned int tlen;
1098   unsigned char digest[64];
1099   gcry_buffer_t hvec[3];
1100   gcry_mpi_t h, s;
1101   mpi_point_struct Ia, Ib;
1102
1103   if (!mpi_is_opaque (input) || !mpi_is_opaque (r_in) || !mpi_is_opaque (s_in))
1104     return GPG_ERR_INV_DATA;
1105   if (hashalgo != GCRY_MD_SHA512)
1106     return GPG_ERR_DIGEST_ALGO;
1107
1108   point_init (&Q);
1109   point_init (&Ia);
1110   point_init (&Ib);
1111   h = mpi_new (0);
1112   s = mpi_new (0);
1113
1114   ctx = _gcry_mpi_ec_p_internal_new (pkey->E.model, pkey->E.dialect,
1115                                      pkey->E.p, pkey->E.a, pkey->E.b);
1116   b = ctx->nbits/8;
1117   if (b != 256/8)
1118     return GPG_ERR_INTERNAL; /* We only support 256 bit. */
1119
1120   /* Decode and check the public key.  */
1121   rc = _gcry_ecc_eddsa_decodepoint (pk, ctx, &Q, &encpk, &encpklen);
1122   if (rc)
1123     goto leave;
1124   if (!_gcry_mpi_ec_curve_point (&Q, ctx))
1125     {
1126       rc = GPG_ERR_BROKEN_PUBKEY;
1127       goto leave;
1128     }
1129   if (DBG_CIPHER)
1130     log_printhex ("  e_pk", encpk, encpklen);
1131   if (encpklen != b)
1132     {
1133       rc = GPG_ERR_INV_LENGTH;
1134       goto leave;
1135     }
1136
1137   /* Convert the other input parameters.  */
1138   mbuf = gcry_mpi_get_opaque (input, &tmp);
1139   mlen = (tmp +7)/8;
1140   if (DBG_CIPHER)
1141     log_printhex ("     m", mbuf, mlen);
1142   rbuf = gcry_mpi_get_opaque (r_in, &tmp);
1143   rlen = (tmp +7)/8;
1144   if (DBG_CIPHER)
1145     log_printhex ("     r", rbuf, rlen);
1146   if (rlen != b)
1147     {
1148       rc = GPG_ERR_INV_LENGTH;
1149       goto leave;
1150     }
1151
1152   /* h = H(encodepoint(R) + encodepoint(pk) + m)  */
1153   hvec[0].data = (char*)rbuf;
1154   hvec[0].off  = 0;
1155   hvec[0].len  = rlen;
1156   hvec[1].data = encpk;
1157   hvec[1].off  = 0;
1158   hvec[1].len  = encpklen;
1159   hvec[2].data = (char*)mbuf;
1160   hvec[2].off  = 0;
1161   hvec[2].len  = mlen;
1162   rc = _gcry_md_hash_buffers (hashalgo, 0, digest, hvec, 3);
1163   if (rc)
1164     goto leave;
1165   reverse_buffer (digest, 64);
1166   if (DBG_CIPHER)
1167     log_printhex (" H(R+)", digest, 64);
1168   _gcry_mpi_set_buffer (h, digest, 64, 0);
1169
1170   /* According to the paper the best way for verification is:
1171          encodepoint(sG - h·Q) = encodepoint(r)
1172      because we don't need to decode R. */
1173   {
1174     void *sbuf;
1175     unsigned int slen;
1176
1177     sbuf = _gcry_mpi_get_opaque_copy (s_in, &tmp);
1178     slen = (tmp +7)/8;
1179     reverse_buffer (sbuf, slen);
1180     if (DBG_CIPHER)
1181       log_printhex ("     s", sbuf, slen);
1182     _gcry_mpi_set_buffer (s, sbuf, slen, 0);
1183     gcry_free (sbuf);
1184     if (slen != b)
1185       {
1186         rc = GPG_ERR_INV_LENGTH;
1187         goto leave;
1188       }
1189   }
1190
1191   _gcry_mpi_ec_mul_point (&Ia, s, &pkey->E.G, ctx);
1192   _gcry_mpi_ec_mul_point (&Ib, h, &Q, ctx);
1193   _gcry_mpi_neg (Ib.x, Ib.x);
1194   _gcry_mpi_ec_add_points (&Ia, &Ia, &Ib, ctx);
1195   rc = _gcry_ecc_eddsa_encodepoint (&Ia, ctx, s, h, &tbuf, &tlen);
1196   if (rc)
1197     goto leave;
1198   if (tlen != rlen || memcmp (tbuf, rbuf, tlen))
1199     {
1200       if (DBG_CIPHER)
1201         log_debug ("eddsa verify: Not verified\n");
1202       rc = GPG_ERR_BAD_SIGNATURE;
1203       goto leave;
1204     }
1205
1206   if (DBG_CIPHER)
1207     log_debug ("eddsa verify: Accepted\n");
1208   rc = 0;
1209
1210  leave:
1211   gcry_free (encpk);
1212   gcry_free (tbuf);
1213   _gcry_mpi_ec_free (ctx);
1214   gcry_mpi_release (s);
1215   gcry_mpi_release (h);
1216   point_free (&Ia);
1217   point_free (&Ib);
1218   point_free (&Q);
1219   return rc;
1220 }
1221
1222
1223 \f
1224 /*********************************************
1225  **************  interface  ******************
1226  *********************************************/
1227
1228 static gcry_err_code_t
1229 ecc_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
1230 {
1231   gpg_err_code_t rc;
1232   unsigned int nbits;
1233   elliptic_curve_t E;
1234   ECC_secret_key sk;
1235   gcry_mpi_t x = NULL;
1236   gcry_mpi_t y = NULL;
1237   char *curve_name = NULL;
1238   gcry_sexp_t l1;
1239   int transient_key = 0;
1240   gcry_random_level_t random_level;
1241   mpi_ec_t ctx = NULL;
1242   gcry_sexp_t curve_info = NULL;
1243   gcry_mpi_t base = NULL;
1244   gcry_mpi_t public = NULL;
1245   gcry_mpi_t secret = NULL;
1246
1247   memset (&E, 0, sizeof E);
1248   memset (&sk, 0, sizeof sk);
1249
1250   rc = _gcry_pk_util_get_nbits (genparms, &nbits);
1251   if (rc)
1252     return rc;
1253
1254   /* Parse the optional "curve" parameter. */
1255   l1 = gcry_sexp_find_token (genparms, "curve", 0);
1256   if (l1)
1257     {
1258       curve_name = _gcry_sexp_nth_string (l1, 1);
1259       gcry_sexp_release (l1);
1260       if (!curve_name)
1261         return GPG_ERR_INV_OBJ; /* No curve name or value too large. */
1262     }
1263
1264   /* Parse the optional transient-key flag.  */
1265   l1 = gcry_sexp_find_token (genparms, "transient-key", 0);
1266   if (l1)
1267     {
1268       transient_key = 1;
1269       gcry_sexp_release (l1);
1270     }
1271
1272   /* NBITS is required if no curve name has been given.  */
1273   if (!nbits && !curve_name)
1274     return GPG_ERR_NO_OBJ; /* No NBITS parameter. */
1275
1276   rc = _gcry_ecc_fill_in_curve (nbits, curve_name, &E, &nbits);
1277   gcry_free (curve_name); curve_name = NULL;
1278   if (rc)
1279     goto leave;
1280
1281   if (DBG_CIPHER)
1282     {
1283       log_debug ("ecgen curve info: %s/%s\n",
1284                  _gcry_ecc_model2str (E.model),
1285                  _gcry_ecc_dialect2str (E.dialect));
1286       if (E.name)
1287         log_debug ("ecgen curve used: %s\n", E.name);
1288       log_printmpi ("ecgen curve   p", E.p);
1289       log_printmpi ("ecgen curve   a", E.a);
1290       log_printmpi ("ecgen curve   b", E.b);
1291       log_printmpi ("ecgen curve   n", E.n);
1292       log_printpnt ("ecgen curve G", &E.G, NULL);
1293     }
1294
1295   random_level = transient_key ? GCRY_STRONG_RANDOM : GCRY_VERY_STRONG_RANDOM;
1296   ctx = _gcry_mpi_ec_p_internal_new (E.model, E.dialect, E.p, E.a, E.b);
1297   x = mpi_new (0);
1298   y = mpi_new (0);
1299
1300   switch (E.dialect)
1301     {
1302     case ECC_DIALECT_STANDARD:
1303       rc = nist_generate_key (&sk, &E, ctx, random_level, nbits);
1304       break;
1305     case ECC_DIALECT_ED25519:
1306       rc = eddsa_generate_key (&sk, &E, ctx, random_level);
1307       break;
1308     default:
1309       rc = GPG_ERR_INTERNAL;
1310       break;
1311     }
1312   if (rc)
1313     goto leave;
1314
1315   /* Copy data to the result.  */
1316   if (_gcry_mpi_ec_get_affine (x, y, &sk.E.G, ctx))
1317     log_fatal ("ecgen: Failed to get affine coordinates for %s\n", "G");
1318   base = _gcry_ecc_ec2os (x, y, sk.E.p);
1319   if (sk.E.dialect == ECC_DIALECT_ED25519)
1320     {
1321       unsigned char *encpk;
1322       unsigned int encpklen;
1323
1324       rc = _gcry_ecc_eddsa_encodepoint (&sk.Q, ctx, x, y, &encpk, &encpklen);
1325       if (rc)
1326         return rc;
1327       public = mpi_new (0);
1328       gcry_mpi_set_opaque (public, encpk, encpklen*8);
1329       encpk = NULL;
1330     }
1331   else
1332     {
1333       if (_gcry_mpi_ec_get_affine (x, y, &sk.Q, ctx))
1334         log_fatal ("ecgen: Failed to get affine coordinates for %s\n", "Q");
1335       public = _gcry_ecc_ec2os (x, y, sk.E.p);
1336     }
1337   secret = sk.d; sk.d = NULL;
1338   if (E.name)
1339     {
1340       rc = gcry_sexp_build (&curve_info, NULL, "(curve %s)", E.name);
1341       if (rc)
1342         goto leave;
1343     }
1344
1345   rc = gcry_sexp_build (r_skey, NULL,
1346                         "(key-data"
1347                         " (public-key"
1348                         "  (ecc%S(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))"
1349                         " (private-key"
1350                         "  (ecc%S(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))"
1351                         " )",
1352                         curve_info,
1353                         sk.E.p, sk.E.a, sk.E.b, base, sk.E.n, public,
1354                         curve_info,
1355                         sk.E.p, sk.E.a, sk.E.b, base, sk.E.n, public, secret);
1356   if (rc)
1357     goto leave;
1358
1359   if (DBG_CIPHER)
1360     {
1361       log_printmpi ("ecgen result  p", sk.E.p);
1362       log_printmpi ("ecgen result  a", sk.E.a);
1363       log_printmpi ("ecgen result  b", sk.E.b);
1364       log_printmpi ("ecgen result  G", base);
1365       log_printmpi ("ecgen result  n", sk.E.n);
1366       log_printmpi ("ecgen result  Q", public);
1367       log_printmpi ("ecgen result  d", secret);
1368     }
1369
1370  leave:
1371   mpi_free (secret);
1372   mpi_free (public);
1373   mpi_free (base);
1374   {
1375     _gcry_ecc_curve_free (&sk.E);
1376     point_free (&sk.Q);
1377     mpi_free (sk.d);
1378   }
1379   _gcry_ecc_curve_free (&E);
1380   mpi_free (x);
1381   mpi_free (y);
1382   _gcry_mpi_ec_free (ctx);
1383   gcry_sexp_release (curve_info);
1384   return rc;
1385 }
1386
1387
1388 static gcry_err_code_t
1389 ecc_check_secret_key (int algo, gcry_mpi_t *skey)
1390 {
1391   gpg_err_code_t err;
1392   ECC_secret_key sk;
1393
1394   (void)algo;
1395
1396   /* FIXME:  This check looks a bit fishy:  Now long is the array?  */
1397   if (!skey[0] || !skey[1] || !skey[2] || !skey[3] || !skey[4] || !skey[5]
1398       || !skey[6])
1399     return GPG_ERR_BAD_MPI;
1400
1401   sk.E.model = MPI_EC_WEIERSTRASS;
1402   sk.E.p = skey[0];
1403   sk.E.a = skey[1];
1404   sk.E.b = skey[2];
1405   point_init (&sk.E.G);
1406   err = _gcry_ecc_os2ec (&sk.E.G, skey[3]);
1407   if (err)
1408     {
1409       point_free (&sk.E.G);
1410       return err;
1411     }
1412   sk.E.n = skey[4];
1413   point_init (&sk.Q);
1414   err = _gcry_ecc_os2ec (&sk.Q, skey[5]);
1415   if (err)
1416     {
1417       point_free (&sk.E.G);
1418       point_free (&sk.Q);
1419       return err;
1420     }
1421
1422   {
1423     const unsigned char *buf;
1424     unsigned int n;
1425
1426     gcry_assert (mpi_is_opaque (skey[6]));
1427
1428     buf = gcry_mpi_get_opaque (skey[6], &n);
1429     if (!buf)
1430       err = GPG_ERR_INV_OBJ;
1431     else
1432       {
1433         n = (n + 7)/8;
1434         sk.d = NULL;
1435         err = gcry_mpi_scan (&sk.d, GCRYMPI_FMT_USG, buf, n, NULL);
1436         if (!err)
1437           {
1438             if (check_secret_key (&sk))
1439               err = GPG_ERR_BAD_SECKEY;
1440             gcry_mpi_release (sk.d);
1441             sk.d = NULL;
1442           }
1443       }
1444   }
1445
1446   point_free (&sk.E.G);
1447   point_free (&sk.Q);
1448   return err;
1449 }
1450
1451
1452 static gcry_err_code_t
1453 ecc_sign (int algo, gcry_sexp_t *r_result, gcry_mpi_t data, gcry_mpi_t *skey,
1454           int flags, int hashalgo)
1455 {
1456   gpg_err_code_t rc;
1457   ECC_secret_key sk;
1458   gcry_mpi_t r, s;
1459
1460   (void)algo;
1461
1462   if (!data || !skey[0] || !skey[1] || !skey[2] || !skey[3] || !skey[4]
1463       || !skey[6] )
1464     return GPG_ERR_BAD_MPI;
1465
1466   /* FIXME: The setting of model and dialect are crude hacks.  We will
1467      fix that by moving the s-expression parsing from pubkey.c to
1468      here.  */
1469   sk.E.model = ((flags & PUBKEY_FLAG_EDDSA)
1470                 ? MPI_EC_TWISTEDEDWARDS
1471                 : MPI_EC_WEIERSTRASS);
1472   sk.E.dialect = ((flags & PUBKEY_FLAG_EDDSA)
1473                   ? ECC_DIALECT_ED25519
1474                   : ECC_DIALECT_STANDARD);
1475   sk.E.p = skey[0];
1476   sk.E.a = skey[1];
1477   sk.E.b = skey[2];
1478   point_init (&sk.E.G);
1479   sk.Q.x = NULL;
1480   sk.Q.y = NULL;
1481   sk.Q.z = NULL;
1482   rc = _gcry_ecc_os2ec (&sk.E.G, skey[3]);
1483   if (rc)
1484     {
1485       point_free (&sk.E.G);
1486       return rc;
1487     }
1488   sk.E.n = skey[4];
1489
1490   r = mpi_alloc (mpi_get_nlimbs (sk.E.p));
1491   s = mpi_alloc (mpi_get_nlimbs (sk.E.p));
1492
1493   {
1494     const unsigned char *buf;
1495     unsigned int n;
1496
1497     gcry_assert (mpi_is_opaque (skey[6]));
1498
1499     buf = gcry_mpi_get_opaque (skey[6], &n);
1500     if (!buf)
1501       rc = GPG_ERR_INV_OBJ;
1502     else
1503       {
1504         n = (n + 7)/8;
1505         sk.d = NULL;
1506         rc = gcry_mpi_scan (&sk.d, GCRYMPI_FMT_USG, buf, n, NULL);
1507         if (!rc)
1508           {
1509             if ((flags & PUBKEY_FLAG_EDDSA))
1510               {
1511                 rc = sign_eddsa (data, &sk, r, s, hashalgo, skey[5]);
1512                 if (!rc)
1513                   rc = gcry_sexp_build (r_result, NULL,
1514                                         "(sig-val(eddsa(r%M)(s%M)))", r, s);
1515               }
1516             else
1517               {
1518                 rc = sign_ecdsa (data, &sk, r, s, flags, hashalgo);
1519                 if (!rc)
1520                   rc = gcry_sexp_build (r_result, NULL,
1521                                         "(sig-val(ecdsa(r%M)(s%M)))", r, s);
1522               }
1523             gcry_mpi_release (sk.d);
1524             sk.d = NULL;
1525           }
1526       }
1527   }
1528
1529   mpi_free (r);
1530   mpi_free (s);
1531   point_free (&sk.E.G);
1532   if (sk.Q.x)
1533     point_free (&sk.Q);
1534   return rc;
1535 }
1536
1537
1538 static gcry_err_code_t
1539 ecc_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
1540             int (*cmp)(void *, gcry_mpi_t), void *opaquev,
1541             int flags, int hashalgo)
1542 {
1543   gpg_err_code_t err;
1544   ECC_public_key pk;
1545
1546   (void)algo;
1547   (void)cmp;
1548   (void)opaquev;
1549
1550   if (!data[0] || !data[1] || !hash || !pkey[0] || !pkey[1] || !pkey[2]
1551       || !pkey[3] || !pkey[4] || !pkey[5] )
1552     return GPG_ERR_BAD_MPI;
1553
1554   /* FIXME: The setting of model and dialect are crude hacks.  We will
1555      fix that by moving the s-expression parsing from pubkey.c to
1556      here.  */
1557   pk.E.model = ((flags & PUBKEY_FLAG_EDDSA)
1558                 ? MPI_EC_TWISTEDEDWARDS
1559                 : MPI_EC_WEIERSTRASS);
1560   pk.E.dialect = ((flags & PUBKEY_FLAG_EDDSA)
1561                   ? ECC_DIALECT_ED25519
1562                   : ECC_DIALECT_STANDARD);
1563   pk.E.p = pkey[0];
1564   pk.E.a = pkey[1];
1565   pk.E.b = pkey[2];
1566   point_init (&pk.E.G);
1567   err = _gcry_ecc_os2ec (&pk.E.G, pkey[3]);
1568   if (err)
1569     {
1570       point_free (&pk.E.G);
1571       return err;
1572     }
1573   pk.E.n = pkey[4];
1574
1575   if ((flags & PUBKEY_FLAG_EDDSA))
1576     {
1577       pk.Q.x = NULL;
1578       pk.Q.y = NULL;
1579       pk.Q.z = NULL;
1580
1581       err = verify_eddsa (hash, &pk, data[0], data[1], hashalgo, pkey[5]);
1582     }
1583   else
1584     {
1585       point_init (&pk.Q);
1586       err = _gcry_ecc_os2ec (&pk.Q, pkey[5]);
1587       if (err)
1588         {
1589           point_free (&pk.E.G);
1590           point_free (&pk.Q);
1591           return err;
1592         }
1593
1594       if (mpi_is_opaque (hash))
1595         {
1596           const void *abuf;
1597           unsigned int abits, qbits;
1598           gcry_mpi_t a;
1599
1600           qbits = mpi_get_nbits (pk.E.n);
1601
1602           abuf = gcry_mpi_get_opaque (hash, &abits);
1603           err = gcry_mpi_scan (&a, GCRYMPI_FMT_USG, abuf, (abits+7)/8, NULL);
1604           if (!err)
1605             {
1606               if (abits > qbits)
1607                 gcry_mpi_rshift (a, a, abits - qbits);
1608
1609               err = verify_ecdsa (a, &pk, data[0], data[1]);
1610               gcry_mpi_release (a);
1611             }
1612         }
1613       else
1614         err = verify_ecdsa (hash, &pk, data[0], data[1]);
1615     }
1616
1617   point_free (&pk.E.G);
1618   point_free (&pk.Q);
1619   return err;
1620 }
1621
1622
1623 /* ecdh raw is classic 2-round DH protocol published in 1976.
1624  *
1625  * Overview of ecc_encrypt_raw and ecc_decrypt_raw.
1626  *
1627  * As with any PK operation, encrypt version uses a public key and
1628  * decrypt -- private.
1629  *
1630  * Symbols used below:
1631  *     G - field generator point
1632  *     d - private long-term scalar
1633  *    dG - public long-term key
1634  *     k - ephemeral scalar
1635  *    kG - ephemeral public key
1636  *   dkG - shared secret
1637  *
1638  * ecc_encrypt_raw description:
1639  *   input:
1640  *     data[0] : private scalar (k)
1641  *   output: A new S-expression with the parameters:
1642  *     s : shared point (kdG)
1643  *     e : generated ephemeral public key (kG)
1644  *
1645  * ecc_decrypt_raw description:
1646  *   input:
1647  *     data[0] : a point kG (ephemeral public key)
1648  *   output:
1649  *     result[0] : shared point (kdG)
1650  */
1651 static gcry_err_code_t
1652 ecc_encrypt_raw (int algo, gcry_sexp_t *r_result, gcry_mpi_t k,
1653                  gcry_mpi_t *pkey, int flags)
1654 {
1655   gpg_err_code_t rc;
1656   ECC_public_key pk;
1657   mpi_ec_t ctx;
1658   gcry_mpi_t s, e;
1659
1660   (void)algo;
1661   (void)flags;
1662
1663   if (!k
1664       || !pkey[0] || !pkey[1] || !pkey[2] || !pkey[3] || !pkey[4] || !pkey[5])
1665     return GPG_ERR_BAD_MPI;
1666
1667   pk.E.model = MPI_EC_WEIERSTRASS;
1668   pk.E.p = pkey[0];
1669   pk.E.a = pkey[1];
1670   pk.E.b = pkey[2];
1671   point_init (&pk.E.G);
1672   rc = _gcry_ecc_os2ec (&pk.E.G, pkey[3]);
1673   if (rc)
1674     {
1675       point_free (&pk.E.G);
1676       return rc;
1677     }
1678   pk.E.n = pkey[4];
1679   point_init (&pk.Q);
1680   rc = _gcry_ecc_os2ec (&pk.Q, pkey[5]);
1681   if (rc)
1682     {
1683       point_free (&pk.E.G);
1684       point_free (&pk.Q);
1685       return rc;
1686     }
1687
1688   ctx = _gcry_mpi_ec_p_internal_new (pk.E.model, pk.E.dialect,
1689                                      pk.E.p, pk.E.a, pk.E.b);
1690   s = mpi_alloc (mpi_get_nlimbs (pk.E.p));
1691   e = mpi_alloc (mpi_get_nlimbs (pk.E.p));
1692
1693   /* The following is false: assert( mpi_cmp_ui( R.x, 1 )==0 );, so */
1694   {
1695     mpi_point_struct R;  /* Result that we return.  */
1696     gcry_mpi_t x, y;
1697
1698     x = mpi_new (0);
1699     y = mpi_new (0);
1700
1701     point_init (&R);
1702
1703     /* R = kQ  <=>  R = kdG  */
1704     _gcry_mpi_ec_mul_point (&R, k, &pk.Q, ctx);
1705
1706     if (_gcry_mpi_ec_get_affine (x, y, &R, ctx))
1707       log_fatal ("ecdh: Failed to get affine coordinates for kdG\n");
1708     s = _gcry_ecc_ec2os (x, y, pk.E.p);
1709
1710     /* R = kG */
1711     _gcry_mpi_ec_mul_point (&R, k, &pk.E.G, ctx);
1712
1713     if (_gcry_mpi_ec_get_affine (x, y, &R, ctx))
1714       log_fatal ("ecdh: Failed to get affine coordinates for kG\n");
1715     e = _gcry_ecc_ec2os (x, y, pk.E.p);
1716
1717     mpi_free (x);
1718     mpi_free (y);
1719
1720     point_free (&R);
1721   }
1722
1723   _gcry_mpi_ec_free (ctx);
1724   point_free (&pk.E.G);
1725   point_free (&pk.Q);
1726
1727   rc = gcry_sexp_build (r_result, NULL, "(enc-val(ecdh(s%m)(e%m)))", s, e);
1728   mpi_free (s);
1729   mpi_free (e);
1730
1731   return rc;
1732 }
1733
1734 /*  input:
1735  *     data[0] : a point kG (ephemeral public key)
1736  *   output:
1737  *     resaddr[0] : shared point kdG
1738  *
1739  *  see ecc_encrypt_raw for details.
1740  */
1741 static gcry_err_code_t
1742 ecc_decrypt_raw (int algo, gcry_sexp_t *r_plain, gcry_mpi_t *data,
1743                  gcry_mpi_t *skey, int flags,
1744                  enum pk_encoding encoding, int hash_algo,
1745                  unsigned char *label, size_t labellen)
1746 {
1747   gpg_err_code_t rc;
1748   ECC_secret_key sk;
1749   mpi_point_struct R;   /* Result that we return.  */
1750   mpi_point_struct kG;
1751   mpi_ec_t ctx;
1752   gcry_mpi_t r;
1753
1754   (void)algo;
1755   (void)flags;
1756   (void)encoding;
1757   (void)hash_algo;
1758   (void)label;
1759   (void)labellen;
1760
1761   if (!data || !data[0]
1762       || !skey[0] || !skey[1] || !skey[2] || !skey[3] || !skey[4]
1763       || !skey[5] || !skey[6] )
1764     return GPG_ERR_BAD_MPI;
1765
1766   point_init (&kG);
1767   rc = _gcry_ecc_os2ec (&kG, data[0]);
1768   if (rc)
1769     {
1770       point_free (&kG);
1771       return rc;
1772     }
1773
1774   sk.E.model = MPI_EC_WEIERSTRASS;
1775   sk.E.p = skey[0];
1776   sk.E.a = skey[1];
1777   sk.E.b = skey[2];
1778   point_init (&sk.E.G);
1779   rc = _gcry_ecc_os2ec (&sk.E.G, skey[3]);
1780   if (rc)
1781     {
1782       point_free (&kG);
1783       point_free (&sk.E.G);
1784       return rc;
1785     }
1786   sk.E.n = skey[4];
1787   point_init (&sk.Q);
1788   rc = _gcry_ecc_os2ec (&sk.Q, skey[5]);
1789   if (rc)
1790     {
1791       point_free (&kG);
1792       point_free (&sk.E.G);
1793       point_free (&sk.Q);
1794       return rc;
1795     }
1796   sk.d = skey[6];
1797
1798   ctx = _gcry_mpi_ec_p_internal_new (sk.E.model, sk.E.dialect,
1799                                      sk.E.p, sk.E.a, sk.E.b);
1800
1801   /* R = dkG */
1802   point_init (&R);
1803   _gcry_mpi_ec_mul_point (&R, sk.d, &kG, ctx);
1804
1805   point_free (&kG);
1806
1807   /* The following is false: assert( mpi_cmp_ui( R.x, 1 )==0 );, so:  */
1808   {
1809     gcry_mpi_t x, y;
1810
1811     x = mpi_new (0);
1812     y = mpi_new (0);
1813
1814     if (_gcry_mpi_ec_get_affine (x, y, &R, ctx))
1815       log_fatal ("ecdh: Failed to get affine coordinates\n");
1816
1817     r = _gcry_ecc_ec2os (x, y, sk.E.p);
1818     if (!r)
1819       rc = gpg_err_code_from_syserror ();
1820     else
1821       rc = 0;
1822     mpi_free (x);
1823     mpi_free (y);
1824   }
1825
1826   point_free (&R);
1827   _gcry_mpi_ec_free (ctx);
1828   point_free (&kG);
1829   point_free (&sk.E.G);
1830   point_free (&sk.Q);
1831
1832   if (!rc)
1833     rc = gcry_sexp_build (r_plain, NULL, "(value %m)", r);
1834   mpi_free (r);
1835   return rc;
1836 }
1837
1838
1839 static unsigned int
1840 ecc_get_nbits (int algo, gcry_mpi_t *pkey)
1841 {
1842   (void)algo;
1843
1844   return mpi_get_nbits (pkey[0]);
1845 }
1846
1847
1848 /* See rsa.c for a description of this function.  */
1849 static gpg_err_code_t
1850 compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparam)
1851 {
1852 #define N_COMPONENTS 6
1853   static const char names[N_COMPONENTS+1] = "pabgnq";
1854   gpg_err_code_t ec = 0;
1855   gcry_sexp_t l1;
1856   gcry_mpi_t values[N_COMPONENTS];
1857   int idx;
1858
1859   /* Clear the values for easier error cleanup.  */
1860   for (idx=0; idx < N_COMPONENTS; idx++)
1861     values[idx] = NULL;
1862
1863   /* Fill values with all provided parameters.  */
1864   for (idx=0; idx < N_COMPONENTS; idx++)
1865     {
1866       l1 = gcry_sexp_find_token (keyparam, names+idx, 1);
1867       if (l1)
1868         {
1869           values[idx] = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
1870           gcry_sexp_release (l1);
1871           if (!values[idx])
1872             {
1873               ec = GPG_ERR_INV_OBJ;
1874               goto leave;
1875             }
1876         }
1877     }
1878
1879   /* Check whether a curve parameter is available and use that to fill
1880      in missing values.  */
1881   l1 = gcry_sexp_find_token (keyparam, "curve", 5);
1882   if (l1)
1883     {
1884       char *curve;
1885       gcry_mpi_t tmpvalues[N_COMPONENTS];
1886
1887       for (idx = 0; idx < N_COMPONENTS; idx++)
1888         tmpvalues[idx] = NULL;
1889
1890       curve = _gcry_sexp_nth_string (l1, 1);
1891       gcry_sexp_release (l1);
1892       if (!curve)
1893         {
1894           ec = GPG_ERR_INV_OBJ; /* Name missing or out of core. */
1895           goto leave;
1896         }
1897       ec = _gcry_ecc_get_param (curve, tmpvalues);
1898       gcry_free (curve);
1899       if (ec)
1900         goto leave;
1901
1902       for (idx = 0; idx < N_COMPONENTS; idx++)
1903         {
1904           if (!values[idx])
1905             values[idx] = tmpvalues[idx];
1906           else
1907             mpi_free (tmpvalues[idx]);
1908         }
1909     }
1910
1911   /* Check that all parameters are known and normalize all MPIs (that
1912      should not be required but we use an internal function later and
1913      thus we better make 100% sure that they are normalized). */
1914   for (idx = 0; idx < N_COMPONENTS; idx++)
1915     if (!values[idx])
1916       {
1917         ec = GPG_ERR_NO_OBJ;
1918         goto leave;
1919       }
1920     else
1921       _gcry_mpi_normalize (values[idx]);
1922
1923   /* Hash them all.  */
1924   for (idx = 0; idx < N_COMPONENTS; idx++)
1925     {
1926       char buf[30];
1927       unsigned char *rawmpi;
1928       unsigned int rawmpilen;
1929
1930       rawmpi = _gcry_mpi_get_buffer (values[idx], 0, &rawmpilen, NULL);
1931       if (!rawmpi)
1932         {
1933           ec = gpg_err_code_from_syserror ();
1934           goto leave;
1935         }
1936       snprintf (buf, sizeof buf, "(1:%c%u:", names[idx], rawmpilen);
1937       gcry_md_write (md, buf, strlen (buf));
1938       gcry_md_write (md, rawmpi, rawmpilen);
1939       gcry_md_write (md, ")", 1);
1940       gcry_free (rawmpi);
1941     }
1942
1943  leave:
1944   for (idx = 0; idx < N_COMPONENTS; idx++)
1945     _gcry_mpi_release (values[idx]);
1946
1947   return ec;
1948 #undef N_COMPONENTS
1949 }
1950
1951
1952 \f
1953 /*
1954    Low-level API helper functions.
1955  */
1956
1957 /* This is the worker function for gcry_pubkey_get_sexp for ECC
1958    algorithms.  Note that the caller has already stored NULL at
1959    R_SEXP.  */
1960 gpg_err_code_t
1961 _gcry_pk_ecc_get_sexp (gcry_sexp_t *r_sexp, int mode, mpi_ec_t ec)
1962 {
1963   gpg_err_code_t rc;
1964   gcry_mpi_t mpi_G = NULL;
1965   gcry_mpi_t mpi_Q = NULL;
1966
1967   if (!ec->p || !ec->a || !ec->b || !ec->G || !ec->n)
1968     return GPG_ERR_BAD_CRYPT_CTX;
1969
1970   if (mode == GCRY_PK_GET_SECKEY && !ec->d)
1971     return GPG_ERR_NO_SECKEY;
1972
1973   /* Compute the public point if it is missing.  */
1974   if (!ec->Q && ec->d)
1975     ec->Q = _gcry_ecc_compute_public (NULL, ec);
1976
1977   /* Encode G and Q.  */
1978   mpi_G = _gcry_mpi_ec_ec2os (ec->G, ec);
1979   if (!mpi_G)
1980     {
1981       rc = GPG_ERR_BROKEN_PUBKEY;
1982       goto leave;
1983     }
1984   if (!ec->Q)
1985     {
1986       rc = GPG_ERR_BAD_CRYPT_CTX;
1987       goto leave;
1988     }
1989
1990   if (ec->dialect == ECC_DIALECT_ED25519)
1991     {
1992       unsigned char *encpk;
1993       unsigned int encpklen;
1994
1995       rc = _gcry_ecc_eddsa_encodepoint (ec->Q, ec, NULL, NULL,
1996                                         &encpk, &encpklen);
1997       if (rc)
1998         goto leave;
1999       mpi_Q = gcry_mpi_set_opaque (NULL, encpk, encpklen*8);
2000       encpk = NULL;
2001     }
2002   else
2003     {
2004       mpi_Q = _gcry_mpi_ec_ec2os (ec->Q, ec);
2005     }
2006   if (!mpi_Q)
2007     {
2008       rc = GPG_ERR_BROKEN_PUBKEY;
2009       goto leave;
2010     }
2011
2012   /* Fixme: We should return a curve name instead of the parameters if
2013      if know that they match a curve.  */
2014
2015   if (ec->d && (!mode || mode == GCRY_PK_GET_SECKEY))
2016     {
2017       /* Let's return a private key. */
2018       rc = gcry_sexp_build
2019         (r_sexp, NULL,
2020          "(private-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))",
2021          ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q, ec->d);
2022     }
2023   else if (ec->Q)
2024     {
2025       /* Let's return a public key.  */
2026       rc = gcry_sexp_build
2027         (r_sexp, NULL,
2028          "(public-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))",
2029          ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q);
2030     }
2031   else
2032     rc = GPG_ERR_BAD_CRYPT_CTX;
2033
2034  leave:
2035   mpi_free (mpi_Q);
2036   mpi_free (mpi_G);
2037   return rc;
2038 }
2039
2040
2041 \f
2042 /*
2043      Self-test section.
2044  */
2045
2046
2047 static gpg_err_code_t
2048 selftests_ecdsa (selftest_report_func_t report)
2049 {
2050   const char *what;
2051   const char *errtxt;
2052
2053   what = "low-level";
2054   errtxt = NULL; /*selftest ();*/
2055   if (errtxt)
2056     goto failed;
2057
2058   /* FIXME:  need more tests.  */
2059
2060   return 0; /* Succeeded. */
2061
2062  failed:
2063   if (report)
2064     report ("pubkey", GCRY_PK_ECC, what, errtxt);
2065   return GPG_ERR_SELFTEST_FAILED;
2066 }
2067
2068
2069 /* Run a full self-test for ALGO and return 0 on success.  */
2070 static gpg_err_code_t
2071 run_selftests (int algo, int extended, selftest_report_func_t report)
2072 {
2073   (void)extended;
2074
2075   if (algo != GCRY_PK_ECC)
2076     return GPG_ERR_PUBKEY_ALGO;
2077
2078   return selftests_ecdsa (report);
2079 }
2080
2081
2082
2083 \f
2084 static const char *ecc_names[] =
2085   {
2086     "ecc",
2087     "ecdsa",
2088     "ecdh",
2089     "eddsa",
2090     NULL,
2091   };
2092
2093 gcry_pk_spec_t _gcry_pubkey_spec_ecc =
2094   {
2095     GCRY_PK_ECC, { 0, 0 },
2096     (GCRY_PK_USAGE_SIGN | GCRY_PK_USAGE_ENCR),
2097     "ECC", ecc_names,
2098     "pabgnq", "pabgnqd", "sw", "rs", "pabgnq",
2099     ecc_generate,
2100     ecc_check_secret_key,
2101     ecc_encrypt_raw,
2102     ecc_decrypt_raw,
2103     ecc_sign,
2104     ecc_verify,
2105     ecc_get_nbits,
2106     run_selftests,
2107     compute_keygrip,
2108     _gcry_ecc_get_param,
2109     _gcry_ecc_get_curve,
2110     _gcry_ecc_get_param_sexp
2111   };