ecc: Fix recomputing of Q for Ed25519.
[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 (int algo, unsigned int nbits, unsigned long evalue,
1230               const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
1231 {
1232   gpg_err_code_t rc;
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   (void)algo;
1248   (void)evalue;
1249
1250   memset (&E, 0, sizeof E);
1251   memset (&sk, 0, sizeof sk);
1252
1253   if (genparms)
1254     {
1255       /* Parse the optional "curve" parameter. */
1256       l1 = gcry_sexp_find_token (genparms, "curve", 0);
1257       if (l1)
1258         {
1259           curve_name = _gcry_sexp_nth_string (l1, 1);
1260           gcry_sexp_release (l1);
1261           if (!curve_name)
1262             return GPG_ERR_INV_OBJ; /* No curve name or value too large. */
1263         }
1264
1265       /* Parse the optional transient-key flag.  */
1266       l1 = gcry_sexp_find_token (genparms, "transient-key", 0);
1267       if (l1)
1268         {
1269           transient_key = 1;
1270           gcry_sexp_release (l1);
1271         }
1272     }
1273
1274   /* NBITS is required if no curve name has been given.  */
1275   if (!nbits && !curve_name)
1276     return GPG_ERR_NO_OBJ; /* No NBITS parameter. */
1277
1278   rc = _gcry_ecc_fill_in_curve (nbits, curve_name, &E, &nbits);
1279   gcry_free (curve_name); curve_name = NULL;
1280   if (rc)
1281     goto leave;
1282
1283   if (DBG_CIPHER)
1284     {
1285       log_debug ("ecgen curve info: %s/%s\n",
1286                  _gcry_ecc_model2str (E.model),
1287                  _gcry_ecc_dialect2str (E.dialect));
1288       if (E.name)
1289         log_debug ("ecgen curve used: %s\n", E.name);
1290       log_printmpi ("ecgen curve   p", E.p);
1291       log_printmpi ("ecgen curve   a", E.a);
1292       log_printmpi ("ecgen curve   b", E.b);
1293       log_printmpi ("ecgen curve   n", E.n);
1294       log_printpnt ("ecgen curve G", &E.G, NULL);
1295     }
1296
1297   random_level = transient_key ? GCRY_STRONG_RANDOM : GCRY_VERY_STRONG_RANDOM;
1298   ctx = _gcry_mpi_ec_p_internal_new (E.model, E.dialect, E.p, E.a, E.b);
1299   x = mpi_new (0);
1300   y = mpi_new (0);
1301
1302   switch (E.dialect)
1303     {
1304     case ECC_DIALECT_STANDARD:
1305       rc = nist_generate_key (&sk, &E, ctx, random_level, nbits);
1306       break;
1307     case ECC_DIALECT_ED25519:
1308       rc = eddsa_generate_key (&sk, &E, ctx, random_level);
1309       break;
1310     default:
1311       rc = GPG_ERR_INTERNAL;
1312       break;
1313     }
1314   if (rc)
1315     goto leave;
1316
1317   /* Copy data to the result.  */
1318   if (_gcry_mpi_ec_get_affine (x, y, &sk.E.G, ctx))
1319     log_fatal ("ecgen: Failed to get affine coordinates for %s\n", "G");
1320   base = _gcry_ecc_ec2os (x, y, sk.E.p);
1321   if (sk.E.dialect == ECC_DIALECT_ED25519)
1322     {
1323       unsigned char *encpk;
1324       unsigned int encpklen;
1325
1326       rc = _gcry_ecc_eddsa_encodepoint (&sk.Q, ctx, x, y, &encpk, &encpklen);
1327       if (rc)
1328         return rc;
1329       public = mpi_new (0);
1330       gcry_mpi_set_opaque (public, encpk, encpklen*8);
1331       encpk = NULL;
1332     }
1333   else
1334     {
1335       if (_gcry_mpi_ec_get_affine (x, y, &sk.Q, ctx))
1336         log_fatal ("ecgen: Failed to get affine coordinates for %s\n", "Q");
1337       public = _gcry_ecc_ec2os (x, y, sk.E.p);
1338     }
1339   secret = sk.d; sk.d = NULL;
1340   if (E.name)
1341     {
1342       rc = gcry_sexp_build (&curve_info, NULL, "(curve %s)", E.name);
1343       if (rc)
1344         goto leave;
1345     }
1346
1347   rc = gcry_sexp_build (r_skey, NULL,
1348                         "(key-data"
1349                         " (public-key"
1350                         "  (ecc%S(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))"
1351                         " (private-key"
1352                         "  (ecc%S(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))"
1353                         " )",
1354                         curve_info,
1355                         sk.E.p, sk.E.a, sk.E.b, base, sk.E.n, public,
1356                         curve_info,
1357                         sk.E.p, sk.E.a, sk.E.b, base, sk.E.n, public, secret);
1358   if (rc)
1359     goto leave;
1360
1361   if (DBG_CIPHER)
1362     {
1363       log_printmpi ("ecgen result  p", sk.E.p);
1364       log_printmpi ("ecgen result  a", sk.E.a);
1365       log_printmpi ("ecgen result  b", sk.E.b);
1366       log_printmpi ("ecgen result  G", base);
1367       log_printmpi ("ecgen result  n", sk.E.n);
1368       log_printmpi ("ecgen result  Q", public);
1369       log_printmpi ("ecgen result  d", secret);
1370     }
1371
1372  leave:
1373   mpi_free (secret);
1374   mpi_free (public);
1375   mpi_free (base);
1376   {
1377     _gcry_ecc_curve_free (&sk.E);
1378     point_free (&sk.Q);
1379     mpi_free (sk.d);
1380   }
1381   _gcry_ecc_curve_free (&E);
1382   mpi_free (x);
1383   mpi_free (y);
1384   _gcry_mpi_ec_free (ctx);
1385   gcry_sexp_release (curve_info);
1386   return rc;
1387 }
1388
1389
1390 static gcry_err_code_t
1391 ecc_check_secret_key (int algo, gcry_mpi_t *skey)
1392 {
1393   gpg_err_code_t err;
1394   ECC_secret_key sk;
1395
1396   (void)algo;
1397
1398   /* FIXME:  This check looks a bit fishy:  Now long is the array?  */
1399   if (!skey[0] || !skey[1] || !skey[2] || !skey[3] || !skey[4] || !skey[5]
1400       || !skey[6])
1401     return GPG_ERR_BAD_MPI;
1402
1403   sk.E.model = MPI_EC_WEIERSTRASS;
1404   sk.E.p = skey[0];
1405   sk.E.a = skey[1];
1406   sk.E.b = skey[2];
1407   point_init (&sk.E.G);
1408   err = _gcry_ecc_os2ec (&sk.E.G, skey[3]);
1409   if (err)
1410     {
1411       point_free (&sk.E.G);
1412       return err;
1413     }
1414   sk.E.n = skey[4];
1415   point_init (&sk.Q);
1416   err = _gcry_ecc_os2ec (&sk.Q, skey[5]);
1417   if (err)
1418     {
1419       point_free (&sk.E.G);
1420       point_free (&sk.Q);
1421       return err;
1422     }
1423
1424   {
1425     const unsigned char *buf;
1426     unsigned int n;
1427
1428     gcry_assert (mpi_is_opaque (skey[6]));
1429
1430     buf = gcry_mpi_get_opaque (skey[6], &n);
1431     if (!buf)
1432       err = GPG_ERR_INV_OBJ;
1433     else
1434       {
1435         n = (n + 7)/8;
1436         sk.d = NULL;
1437         err = gcry_mpi_scan (&sk.d, GCRYMPI_FMT_USG, buf, n, NULL);
1438         if (!err)
1439           {
1440             if (check_secret_key (&sk))
1441               err = GPG_ERR_BAD_SECKEY;
1442             gcry_mpi_release (sk.d);
1443             sk.d = NULL;
1444           }
1445       }
1446   }
1447
1448   point_free (&sk.E.G);
1449   point_free (&sk.Q);
1450   return err;
1451 }
1452
1453
1454 static gcry_err_code_t
1455 ecc_sign (int algo, gcry_sexp_t *r_result, gcry_mpi_t data, gcry_mpi_t *skey,
1456           int flags, int hashalgo)
1457 {
1458   gpg_err_code_t rc;
1459   ECC_secret_key sk;
1460   gcry_mpi_t r, s;
1461
1462   (void)algo;
1463
1464   if (!data || !skey[0] || !skey[1] || !skey[2] || !skey[3] || !skey[4]
1465       || !skey[6] )
1466     return GPG_ERR_BAD_MPI;
1467
1468   /* FIXME: The setting of model and dialect are crude hacks.  We will
1469      fix that by moving the s-expression parsing from pubkey.c to
1470      here.  */
1471   sk.E.model = ((flags & PUBKEY_FLAG_EDDSA)
1472                 ? MPI_EC_TWISTEDEDWARDS
1473                 : MPI_EC_WEIERSTRASS);
1474   sk.E.dialect = ((flags & PUBKEY_FLAG_EDDSA)
1475                   ? ECC_DIALECT_ED25519
1476                   : ECC_DIALECT_STANDARD);
1477   sk.E.p = skey[0];
1478   sk.E.a = skey[1];
1479   sk.E.b = skey[2];
1480   point_init (&sk.E.G);
1481   sk.Q.x = NULL;
1482   sk.Q.y = NULL;
1483   sk.Q.z = NULL;
1484   rc = _gcry_ecc_os2ec (&sk.E.G, skey[3]);
1485   if (rc)
1486     {
1487       point_free (&sk.E.G);
1488       return rc;
1489     }
1490   sk.E.n = skey[4];
1491
1492   r = mpi_alloc (mpi_get_nlimbs (sk.E.p));
1493   s = mpi_alloc (mpi_get_nlimbs (sk.E.p));
1494
1495   {
1496     const unsigned char *buf;
1497     unsigned int n;
1498
1499     gcry_assert (mpi_is_opaque (skey[6]));
1500
1501     buf = gcry_mpi_get_opaque (skey[6], &n);
1502     if (!buf)
1503       rc = GPG_ERR_INV_OBJ;
1504     else
1505       {
1506         n = (n + 7)/8;
1507         sk.d = NULL;
1508         rc = gcry_mpi_scan (&sk.d, GCRYMPI_FMT_USG, buf, n, NULL);
1509         if (!rc)
1510           {
1511             if ((flags & PUBKEY_FLAG_EDDSA))
1512               {
1513                 rc = sign_eddsa (data, &sk, r, s, hashalgo, skey[5]);
1514                 if (!rc)
1515                   rc = gcry_sexp_build (r_result, NULL,
1516                                         "(sig-val(eddsa(r%M)(s%M)))", r, s);
1517               }
1518             else
1519               {
1520                 rc = sign_ecdsa (data, &sk, r, s, flags, hashalgo);
1521                 if (!rc)
1522                   rc = gcry_sexp_build (r_result, NULL,
1523                                         "(sig-val(ecdsa(r%M)(s%M)))", r, s);
1524               }
1525             gcry_mpi_release (sk.d);
1526             sk.d = NULL;
1527           }
1528       }
1529   }
1530
1531   mpi_free (r);
1532   mpi_free (s);
1533   point_free (&sk.E.G);
1534   if (sk.Q.x)
1535     point_free (&sk.Q);
1536   return rc;
1537 }
1538
1539
1540 static gcry_err_code_t
1541 ecc_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
1542             int (*cmp)(void *, gcry_mpi_t), void *opaquev,
1543             int flags, int hashalgo)
1544 {
1545   gpg_err_code_t err;
1546   ECC_public_key pk;
1547
1548   (void)algo;
1549   (void)cmp;
1550   (void)opaquev;
1551
1552   if (!data[0] || !data[1] || !hash || !pkey[0] || !pkey[1] || !pkey[2]
1553       || !pkey[3] || !pkey[4] || !pkey[5] )
1554     return GPG_ERR_BAD_MPI;
1555
1556   /* FIXME: The setting of model and dialect are crude hacks.  We will
1557      fix that by moving the s-expression parsing from pubkey.c to
1558      here.  */
1559   pk.E.model = ((flags & PUBKEY_FLAG_EDDSA)
1560                 ? MPI_EC_TWISTEDEDWARDS
1561                 : MPI_EC_WEIERSTRASS);
1562   pk.E.dialect = ((flags & PUBKEY_FLAG_EDDSA)
1563                   ? ECC_DIALECT_ED25519
1564                   : ECC_DIALECT_STANDARD);
1565   pk.E.p = pkey[0];
1566   pk.E.a = pkey[1];
1567   pk.E.b = pkey[2];
1568   point_init (&pk.E.G);
1569   err = _gcry_ecc_os2ec (&pk.E.G, pkey[3]);
1570   if (err)
1571     {
1572       point_free (&pk.E.G);
1573       return err;
1574     }
1575   pk.E.n = pkey[4];
1576
1577   if ((flags & PUBKEY_FLAG_EDDSA))
1578     {
1579       pk.Q.x = NULL;
1580       pk.Q.y = NULL;
1581       pk.Q.z = NULL;
1582
1583       err = verify_eddsa (hash, &pk, data[0], data[1], hashalgo, pkey[5]);
1584     }
1585   else
1586     {
1587       point_init (&pk.Q);
1588       err = _gcry_ecc_os2ec (&pk.Q, pkey[5]);
1589       if (err)
1590         {
1591           point_free (&pk.E.G);
1592           point_free (&pk.Q);
1593           return err;
1594         }
1595
1596       if (mpi_is_opaque (hash))
1597         {
1598           const void *abuf;
1599           unsigned int abits, qbits;
1600           gcry_mpi_t a;
1601
1602           qbits = mpi_get_nbits (pk.E.n);
1603
1604           abuf = gcry_mpi_get_opaque (hash, &abits);
1605           err = gcry_mpi_scan (&a, GCRYMPI_FMT_USG, abuf, (abits+7)/8, NULL);
1606           if (!err)
1607             {
1608               if (abits > qbits)
1609                 gcry_mpi_rshift (a, a, abits - qbits);
1610
1611               err = verify_ecdsa (a, &pk, data[0], data[1]);
1612               gcry_mpi_release (a);
1613             }
1614         }
1615       else
1616         err = verify_ecdsa (hash, &pk, data[0], data[1]);
1617     }
1618
1619   point_free (&pk.E.G);
1620   point_free (&pk.Q);
1621   return err;
1622 }
1623
1624
1625 /* ecdh raw is classic 2-round DH protocol published in 1976.
1626  *
1627  * Overview of ecc_encrypt_raw and ecc_decrypt_raw.
1628  *
1629  * As with any PK operation, encrypt version uses a public key and
1630  * decrypt -- private.
1631  *
1632  * Symbols used below:
1633  *     G - field generator point
1634  *     d - private long-term scalar
1635  *    dG - public long-term key
1636  *     k - ephemeral scalar
1637  *    kG - ephemeral public key
1638  *   dkG - shared secret
1639  *
1640  * ecc_encrypt_raw description:
1641  *   input:
1642  *     data[0] : private scalar (k)
1643  *   output: A new S-expression with the parameters:
1644  *     s : shared point (kdG)
1645  *     e : generated ephemeral public key (kG)
1646  *
1647  * ecc_decrypt_raw description:
1648  *   input:
1649  *     data[0] : a point kG (ephemeral public key)
1650  *   output:
1651  *     result[0] : shared point (kdG)
1652  */
1653 static gcry_err_code_t
1654 ecc_encrypt_raw (int algo, gcry_sexp_t *r_result, gcry_mpi_t k,
1655                  gcry_mpi_t *pkey, int flags)
1656 {
1657   gpg_err_code_t rc;
1658   ECC_public_key pk;
1659   mpi_ec_t ctx;
1660   gcry_mpi_t s, e;
1661
1662   (void)algo;
1663   (void)flags;
1664
1665   if (!k
1666       || !pkey[0] || !pkey[1] || !pkey[2] || !pkey[3] || !pkey[4] || !pkey[5])
1667     return GPG_ERR_BAD_MPI;
1668
1669   pk.E.model = MPI_EC_WEIERSTRASS;
1670   pk.E.p = pkey[0];
1671   pk.E.a = pkey[1];
1672   pk.E.b = pkey[2];
1673   point_init (&pk.E.G);
1674   rc = _gcry_ecc_os2ec (&pk.E.G, pkey[3]);
1675   if (rc)
1676     {
1677       point_free (&pk.E.G);
1678       return rc;
1679     }
1680   pk.E.n = pkey[4];
1681   point_init (&pk.Q);
1682   rc = _gcry_ecc_os2ec (&pk.Q, pkey[5]);
1683   if (rc)
1684     {
1685       point_free (&pk.E.G);
1686       point_free (&pk.Q);
1687       return rc;
1688     }
1689
1690   ctx = _gcry_mpi_ec_p_internal_new (pk.E.model, pk.E.dialect,
1691                                      pk.E.p, pk.E.a, pk.E.b);
1692   s = mpi_alloc (mpi_get_nlimbs (pk.E.p));
1693   e = mpi_alloc (mpi_get_nlimbs (pk.E.p));
1694
1695   /* The following is false: assert( mpi_cmp_ui( R.x, 1 )==0 );, so */
1696   {
1697     mpi_point_struct R;  /* Result that we return.  */
1698     gcry_mpi_t x, y;
1699
1700     x = mpi_new (0);
1701     y = mpi_new (0);
1702
1703     point_init (&R);
1704
1705     /* R = kQ  <=>  R = kdG  */
1706     _gcry_mpi_ec_mul_point (&R, k, &pk.Q, ctx);
1707
1708     if (_gcry_mpi_ec_get_affine (x, y, &R, ctx))
1709       log_fatal ("ecdh: Failed to get affine coordinates for kdG\n");
1710     s = _gcry_ecc_ec2os (x, y, pk.E.p);
1711
1712     /* R = kG */
1713     _gcry_mpi_ec_mul_point (&R, k, &pk.E.G, ctx);
1714
1715     if (_gcry_mpi_ec_get_affine (x, y, &R, ctx))
1716       log_fatal ("ecdh: Failed to get affine coordinates for kG\n");
1717     e = _gcry_ecc_ec2os (x, y, pk.E.p);
1718
1719     mpi_free (x);
1720     mpi_free (y);
1721
1722     point_free (&R);
1723   }
1724
1725   _gcry_mpi_ec_free (ctx);
1726   point_free (&pk.E.G);
1727   point_free (&pk.Q);
1728
1729   rc = gcry_sexp_build (r_result, NULL, "(enc-val(ecdh(s%m)(e%m)))", s, e);
1730   mpi_free (s);
1731   mpi_free (e);
1732
1733   return rc;
1734 }
1735
1736 /*  input:
1737  *     data[0] : a point kG (ephemeral public key)
1738  *   output:
1739  *     resaddr[0] : shared point kdG
1740  *
1741  *  see ecc_encrypt_raw for details.
1742  */
1743 static gcry_err_code_t
1744 ecc_decrypt_raw (int algo, gcry_sexp_t *r_plain, gcry_mpi_t *data,
1745                  gcry_mpi_t *skey, int flags,
1746                  enum pk_encoding encoding, int hash_algo,
1747                  unsigned char *label, size_t labellen)
1748 {
1749   gpg_err_code_t rc;
1750   ECC_secret_key sk;
1751   mpi_point_struct R;   /* Result that we return.  */
1752   mpi_point_struct kG;
1753   mpi_ec_t ctx;
1754   gcry_mpi_t r;
1755
1756   (void)algo;
1757   (void)flags;
1758   (void)encoding;
1759   (void)hash_algo;
1760   (void)label;
1761   (void)labellen;
1762
1763   if (!data || !data[0]
1764       || !skey[0] || !skey[1] || !skey[2] || !skey[3] || !skey[4]
1765       || !skey[5] || !skey[6] )
1766     return GPG_ERR_BAD_MPI;
1767
1768   point_init (&kG);
1769   rc = _gcry_ecc_os2ec (&kG, data[0]);
1770   if (rc)
1771     {
1772       point_free (&kG);
1773       return rc;
1774     }
1775
1776   sk.E.model = MPI_EC_WEIERSTRASS;
1777   sk.E.p = skey[0];
1778   sk.E.a = skey[1];
1779   sk.E.b = skey[2];
1780   point_init (&sk.E.G);
1781   rc = _gcry_ecc_os2ec (&sk.E.G, skey[3]);
1782   if (rc)
1783     {
1784       point_free (&kG);
1785       point_free (&sk.E.G);
1786       return rc;
1787     }
1788   sk.E.n = skey[4];
1789   point_init (&sk.Q);
1790   rc = _gcry_ecc_os2ec (&sk.Q, skey[5]);
1791   if (rc)
1792     {
1793       point_free (&kG);
1794       point_free (&sk.E.G);
1795       point_free (&sk.Q);
1796       return rc;
1797     }
1798   sk.d = skey[6];
1799
1800   ctx = _gcry_mpi_ec_p_internal_new (sk.E.model, sk.E.dialect,
1801                                      sk.E.p, sk.E.a, sk.E.b);
1802
1803   /* R = dkG */
1804   point_init (&R);
1805   _gcry_mpi_ec_mul_point (&R, sk.d, &kG, ctx);
1806
1807   point_free (&kG);
1808
1809   /* The following is false: assert( mpi_cmp_ui( R.x, 1 )==0 );, so:  */
1810   {
1811     gcry_mpi_t x, y;
1812
1813     x = mpi_new (0);
1814     y = mpi_new (0);
1815
1816     if (_gcry_mpi_ec_get_affine (x, y, &R, ctx))
1817       log_fatal ("ecdh: Failed to get affine coordinates\n");
1818
1819     r = _gcry_ecc_ec2os (x, y, sk.E.p);
1820     if (!r)
1821       rc = gpg_err_code_from_syserror ();
1822     else
1823       rc = 0;
1824     mpi_free (x);
1825     mpi_free (y);
1826   }
1827
1828   point_free (&R);
1829   _gcry_mpi_ec_free (ctx);
1830   point_free (&kG);
1831   point_free (&sk.E.G);
1832   point_free (&sk.Q);
1833
1834   if (!rc)
1835     rc = gcry_sexp_build (r_plain, NULL, "(value %m)", r);
1836   mpi_free (r);
1837   return rc;
1838 }
1839
1840
1841 static unsigned int
1842 ecc_get_nbits (int algo, gcry_mpi_t *pkey)
1843 {
1844   (void)algo;
1845
1846   return mpi_get_nbits (pkey[0]);
1847 }
1848
1849
1850 /* See rsa.c for a description of this function.  */
1851 static gpg_err_code_t
1852 compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparam)
1853 {
1854 #define N_COMPONENTS 6
1855   static const char names[N_COMPONENTS+1] = "pabgnq";
1856   gpg_err_code_t ec = 0;
1857   gcry_sexp_t l1;
1858   gcry_mpi_t values[N_COMPONENTS];
1859   int idx;
1860
1861   /* Clear the values for easier error cleanup.  */
1862   for (idx=0; idx < N_COMPONENTS; idx++)
1863     values[idx] = NULL;
1864
1865   /* Fill values with all provided parameters.  */
1866   for (idx=0; idx < N_COMPONENTS; idx++)
1867     {
1868       l1 = gcry_sexp_find_token (keyparam, names+idx, 1);
1869       if (l1)
1870         {
1871           values[idx] = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
1872           gcry_sexp_release (l1);
1873           if (!values[idx])
1874             {
1875               ec = GPG_ERR_INV_OBJ;
1876               goto leave;
1877             }
1878         }
1879     }
1880
1881   /* Check whether a curve parameter is available and use that to fill
1882      in missing values.  */
1883   l1 = gcry_sexp_find_token (keyparam, "curve", 5);
1884   if (l1)
1885     {
1886       char *curve;
1887       gcry_mpi_t tmpvalues[N_COMPONENTS];
1888
1889       for (idx = 0; idx < N_COMPONENTS; idx++)
1890         tmpvalues[idx] = NULL;
1891
1892       curve = _gcry_sexp_nth_string (l1, 1);
1893       gcry_sexp_release (l1);
1894       if (!curve)
1895         {
1896           ec = GPG_ERR_INV_OBJ; /* Name missing or out of core. */
1897           goto leave;
1898         }
1899       ec = _gcry_ecc_get_param (curve, tmpvalues);
1900       gcry_free (curve);
1901       if (ec)
1902         goto leave;
1903
1904       for (idx = 0; idx < N_COMPONENTS; idx++)
1905         {
1906           if (!values[idx])
1907             values[idx] = tmpvalues[idx];
1908           else
1909             mpi_free (tmpvalues[idx]);
1910         }
1911     }
1912
1913   /* Check that all parameters are known and normalize all MPIs (that
1914      should not be required but we use an internal function later and
1915      thus we better make 100% sure that they are normalized). */
1916   for (idx = 0; idx < N_COMPONENTS; idx++)
1917     if (!values[idx])
1918       {
1919         ec = GPG_ERR_NO_OBJ;
1920         goto leave;
1921       }
1922     else
1923       _gcry_mpi_normalize (values[idx]);
1924
1925   /* Hash them all.  */
1926   for (idx = 0; idx < N_COMPONENTS; idx++)
1927     {
1928       char buf[30];
1929       unsigned char *rawmpi;
1930       unsigned int rawmpilen;
1931
1932       rawmpi = _gcry_mpi_get_buffer (values[idx], 0, &rawmpilen, NULL);
1933       if (!rawmpi)
1934         {
1935           ec = gpg_err_code_from_syserror ();
1936           goto leave;
1937         }
1938       snprintf (buf, sizeof buf, "(1:%c%u:", names[idx], rawmpilen);
1939       gcry_md_write (md, buf, strlen (buf));
1940       gcry_md_write (md, rawmpi, rawmpilen);
1941       gcry_md_write (md, ")", 1);
1942       gcry_free (rawmpi);
1943     }
1944
1945  leave:
1946   for (idx = 0; idx < N_COMPONENTS; idx++)
1947     _gcry_mpi_release (values[idx]);
1948
1949   return ec;
1950 #undef N_COMPONENTS
1951 }
1952
1953
1954 \f
1955 /*
1956    Low-level API helper functions.
1957  */
1958
1959 /* This is the worker function for gcry_pubkey_get_sexp for ECC
1960    algorithms.  Note that the caller has already stored NULL at
1961    R_SEXP.  */
1962 gpg_err_code_t
1963 _gcry_pk_ecc_get_sexp (gcry_sexp_t *r_sexp, int mode, mpi_ec_t ec)
1964 {
1965   gpg_err_code_t rc;
1966   gcry_mpi_t mpi_G = NULL;
1967   gcry_mpi_t mpi_Q = NULL;
1968
1969   if (!ec->p || !ec->a || !ec->b || !ec->G || !ec->n)
1970     return GPG_ERR_BAD_CRYPT_CTX;
1971
1972   if (mode == GCRY_PK_GET_SECKEY && !ec->d)
1973     return GPG_ERR_NO_SECKEY;
1974
1975   /* Compute the public point if it is missing.  */
1976   if (!ec->Q && ec->d)
1977     ec->Q = _gcry_ecc_compute_public (NULL, ec);
1978
1979   /* Encode G and Q.  */
1980   mpi_G = _gcry_mpi_ec_ec2os (ec->G, ec);
1981   if (!mpi_G)
1982     {
1983       rc = GPG_ERR_BROKEN_PUBKEY;
1984       goto leave;
1985     }
1986   if (!ec->Q)
1987     {
1988       rc = GPG_ERR_BAD_CRYPT_CTX;
1989       goto leave;
1990     }
1991
1992   if (ec->dialect == ECC_DIALECT_ED25519)
1993     {
1994       unsigned char *encpk;
1995       unsigned int encpklen;
1996
1997       rc = _gcry_ecc_eddsa_encodepoint (ec->Q, ec, NULL, NULL,
1998                                         &encpk, &encpklen);
1999       if (rc)
2000         goto leave;
2001       mpi_Q = gcry_mpi_set_opaque (NULL, encpk, encpklen*8);
2002       encpk = NULL;
2003     }
2004   else
2005     {
2006       mpi_Q = _gcry_mpi_ec_ec2os (ec->Q, ec);
2007     }
2008   if (!mpi_Q)
2009     {
2010       rc = GPG_ERR_BROKEN_PUBKEY;
2011       goto leave;
2012     }
2013
2014   /* Fixme: We should return a curve name instead of the parameters if
2015      if know that they match a curve.  */
2016
2017   if (ec->d && (!mode || mode == GCRY_PK_GET_SECKEY))
2018     {
2019       /* Let's return a private key. */
2020       rc = gcry_sexp_build
2021         (r_sexp, NULL,
2022          "(private-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))",
2023          ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q, ec->d);
2024     }
2025   else if (ec->Q)
2026     {
2027       /* Let's return a public key.  */
2028       rc = gcry_sexp_build
2029         (r_sexp, NULL,
2030          "(public-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))",
2031          ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q);
2032     }
2033   else
2034     rc = GPG_ERR_BAD_CRYPT_CTX;
2035
2036  leave:
2037   mpi_free (mpi_Q);
2038   mpi_free (mpi_G);
2039   return rc;
2040 }
2041
2042
2043 \f
2044 /*
2045      Self-test section.
2046  */
2047
2048
2049 static gpg_err_code_t
2050 selftests_ecdsa (selftest_report_func_t report)
2051 {
2052   const char *what;
2053   const char *errtxt;
2054
2055   what = "low-level";
2056   errtxt = NULL; /*selftest ();*/
2057   if (errtxt)
2058     goto failed;
2059
2060   /* FIXME:  need more tests.  */
2061
2062   return 0; /* Succeeded. */
2063
2064  failed:
2065   if (report)
2066     report ("pubkey", GCRY_PK_ECC, what, errtxt);
2067   return GPG_ERR_SELFTEST_FAILED;
2068 }
2069
2070
2071 /* Run a full self-test for ALGO and return 0 on success.  */
2072 static gpg_err_code_t
2073 run_selftests (int algo, int extended, selftest_report_func_t report)
2074 {
2075   (void)extended;
2076
2077   if (algo != GCRY_PK_ECC)
2078     return GPG_ERR_PUBKEY_ALGO;
2079
2080   return selftests_ecdsa (report);
2081 }
2082
2083
2084
2085 \f
2086 static const char *ecc_names[] =
2087   {
2088     "ecc",
2089     "ecdsa",
2090     "ecdh",
2091     "eddsa",
2092     NULL,
2093   };
2094
2095 gcry_pk_spec_t _gcry_pubkey_spec_ecc =
2096   {
2097     GCRY_PK_ECC, { 0, 0 },
2098     (GCRY_PK_USAGE_SIGN | GCRY_PK_USAGE_ENCR),
2099     "ECC", ecc_names,
2100     "pabgnq", "pabgnqd", "sw", "rs", "pabgnq",
2101     ecc_generate,
2102     ecc_check_secret_key,
2103     ecc_encrypt_raw,
2104     ecc_decrypt_raw,
2105     ecc_sign,
2106     ecc_verify,
2107     ecc_get_nbits,
2108     run_selftests,
2109     compute_keygrip,
2110     _gcry_ecc_get_param,
2111     _gcry_ecc_get_curve,
2112     _gcry_ecc_get_param_sexp
2113   };