abd501f769c5d754b4ada5f7fa8d3553c45664b1
[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 hash_d[64];  /* Fixme: malloc in secure memory */
913   unsigned char digest[64];
914   gcry_buffer_t hvec[3];
915   const void *mbuf;
916   size_t mlen;
917   unsigned char *rawmpi = NULL;
918   unsigned int rawmpilen;
919   unsigned char *encpk = NULL; /* Encoded public key.  */
920   unsigned int encpklen;
921   mpi_point_struct I;          /* Intermediate value.  */
922   mpi_point_struct Q;          /* Public key.  */
923   gcry_mpi_t a, x, y, r;
924
925   memset (hvec, 0, sizeof hvec);
926
927   if (!mpi_is_opaque (input))
928     return GPG_ERR_INV_DATA;
929   if (hashalgo != GCRY_MD_SHA512)
930     return GPG_ERR_DIGEST_ALGO;
931
932   /* Initialize some helpers.  */
933   point_init (&I);
934   point_init (&Q);
935   a = mpi_snew (0);
936   x = mpi_new (0);
937   y = mpi_new (0);
938   r = mpi_new (0);
939   ctx = _gcry_mpi_ec_p_internal_new (skey->E.model, skey->E.dialect,
940                                      skey->E.p, skey->E.a, skey->E.b);
941   b = ctx->nbits/8;
942   if (b != 256/8)
943     return GPG_ERR_INTERNAL; /* We only support 256 bit. */
944
945
946   /* Hash the secret key.  We clear DIGEST so we can use it to left
947      pad the key with zeroes for hashing.  */
948   rawmpi = _gcry_mpi_get_buffer (skey->d, 0, &rawmpilen, NULL);
949   if (!rawmpi)
950     {
951       rc = gpg_err_code_from_syserror ();
952       goto leave;
953     }
954   memset (digest, 0, b);
955   hvec[0].data = digest;
956   hvec[0].off = 0;
957   hvec[0].len = b > rawmpilen? b - rawmpilen : 0;
958   hvec[1].data = rawmpi;
959   hvec[1].off = 0;
960   hvec[1].len = rawmpilen;
961   rc = _gcry_md_hash_buffers (hashalgo, 0, hash_d, hvec, 2);
962   gcry_free (rawmpi); rawmpi = NULL;
963   if (rc)
964     goto leave;
965
966   /* Compute the A value (this modifies hash_d).  */
967   reverse_buffer (hash_d, 32);  /* Only the first half of the hash.  */
968   hash_d[0] = (hash_d[0] & 0x7f) | 0x40;
969   hash_d[31] &= 0xf8;
970   _gcry_mpi_set_buffer (a, hash_d, 32, 0);
971   /* log_printmpi ("     a", a); */
972
973   /* Compute the public key if it has not been supplied as optional
974      parameter.  */
975   if (pk)
976     {
977       rc = _gcry_ecc_eddsa_decodepoint (pk, ctx, &Q,  &encpk, &encpklen);
978       if (rc)
979         goto leave;
980       if (DBG_CIPHER)
981         log_printhex ("* e_pk", encpk, encpklen);
982       if (!_gcry_mpi_ec_curve_point (&Q, ctx))
983         {
984           rc = GPG_ERR_BROKEN_PUBKEY;
985           goto leave;
986         }
987     }
988   else
989     {
990       _gcry_mpi_ec_mul_point (&Q, a, &skey->E.G, ctx);
991       rc = _gcry_ecc_eddsa_encodepoint (&Q, ctx, x, y, &encpk, &encpklen);
992       if (rc)
993         goto leave;
994       if (DBG_CIPHER)
995         log_printhex ("  e_pk", encpk, encpklen);
996     }
997
998   /* Compute R.  */
999   mbuf = gcry_mpi_get_opaque (input, &tmp);
1000   mlen = (tmp +7)/8;
1001   if (DBG_CIPHER)
1002     log_printhex ("     m", mbuf, mlen);
1003
1004   hvec[0].data = hash_d;
1005   hvec[0].off  = 32;
1006   hvec[0].len  = 32;
1007   hvec[1].data = (char*)mbuf;
1008   hvec[1].len  = mlen;
1009   rc = _gcry_md_hash_buffers (hashalgo, 0, digest, hvec, 2);
1010   if (rc)
1011     goto leave;
1012   reverse_buffer (digest, 64);
1013   if (DBG_CIPHER)
1014     log_printhex ("     r", digest, 64);
1015   _gcry_mpi_set_buffer (r, digest, 64, 0);
1016   _gcry_mpi_ec_mul_point (&I, r, &skey->E.G, ctx);
1017   if (DBG_CIPHER)
1018     log_printpnt ("   r", &I, ctx);
1019
1020   /* Convert R into affine coordinates and apply encoding.  */
1021   rc = _gcry_ecc_eddsa_encodepoint (&I, ctx, x, y, &rawmpi, &rawmpilen);
1022   if (rc)
1023     goto leave;
1024   if (DBG_CIPHER)
1025     log_printhex ("   e_r", rawmpi, rawmpilen);
1026
1027   /* S = r + a * H(encodepoint(R) + encodepoint(pk) + m) mod n  */
1028   hvec[0].data = rawmpi;  /* (this is R) */
1029   hvec[0].off  = 0;
1030   hvec[0].len  = rawmpilen;
1031   hvec[1].data = encpk;
1032   hvec[1].off  = 0;
1033   hvec[1].len  = encpklen;
1034   hvec[2].data = (char*)mbuf;
1035   hvec[2].off  = 0;
1036   hvec[2].len  = mlen;
1037   rc = _gcry_md_hash_buffers (hashalgo, 0, digest, hvec, 3);
1038   if (rc)
1039     goto leave;
1040
1041   /* No more need for RAWMPI thus we now transfer it to R_R.  */
1042   gcry_mpi_set_opaque (r_r, rawmpi, rawmpilen*8);
1043   rawmpi = NULL;
1044
1045   reverse_buffer (digest, 64);
1046   if (DBG_CIPHER)
1047     log_printhex (" H(R+)", digest, 64);
1048   _gcry_mpi_set_buffer (s, digest, 64, 0);
1049   mpi_mulm (s, s, a, skey->E.n);
1050   mpi_addm (s, s, r, skey->E.n);
1051   rc = eddsa_encodempi (s, b, &rawmpi, &rawmpilen);
1052   if (rc)
1053     goto leave;
1054   if (DBG_CIPHER)
1055     log_printhex ("   e_s", rawmpi, rawmpilen);
1056   gcry_mpi_set_opaque (s, rawmpi, rawmpilen*8);
1057   rawmpi = NULL;
1058
1059   rc = 0;
1060
1061  leave:
1062   gcry_mpi_release (a);
1063   gcry_mpi_release (x);
1064   gcry_mpi_release (y);
1065   gcry_mpi_release (r);
1066   _gcry_mpi_ec_free (ctx);
1067   point_free (&I);
1068   point_free (&Q);
1069   gcry_free (encpk);
1070   gcry_free (rawmpi);
1071   return rc;
1072 }
1073
1074
1075 /* Verify an EdDSA signature.  See sign_eddsa for the reference.
1076  * Check if R_IN and S_IN verifies INPUT.  PKEY has the curve
1077  * parameters and PK is the EdDSA style encoded public key.
1078  */
1079 static gpg_err_code_t
1080 verify_eddsa (gcry_mpi_t input, ECC_public_key *pkey,
1081               gcry_mpi_t r_in, gcry_mpi_t s_in, int hashalgo, gcry_mpi_t pk)
1082 {
1083   int rc;
1084   mpi_ec_t ctx = NULL;
1085   int b;
1086   unsigned int tmp;
1087   mpi_point_struct Q;          /* Public key.  */
1088   unsigned char *encpk = NULL; /* Encoded public key.  */
1089   unsigned int encpklen;
1090   const void *mbuf, *rbuf;
1091   unsigned char *tbuf = NULL;
1092   size_t mlen, rlen;
1093   unsigned int tlen;
1094   unsigned char digest[64];
1095   gcry_buffer_t hvec[3];
1096   gcry_mpi_t h, s;
1097   mpi_point_struct Ia, Ib;
1098
1099   if (!mpi_is_opaque (input) || !mpi_is_opaque (r_in) || !mpi_is_opaque (s_in))
1100     return GPG_ERR_INV_DATA;
1101   if (hashalgo != GCRY_MD_SHA512)
1102     return GPG_ERR_DIGEST_ALGO;
1103
1104   point_init (&Q);
1105   point_init (&Ia);
1106   point_init (&Ib);
1107   h = mpi_new (0);
1108   s = mpi_new (0);
1109
1110   ctx = _gcry_mpi_ec_p_internal_new (pkey->E.model, pkey->E.dialect,
1111                                      pkey->E.p, pkey->E.a, pkey->E.b);
1112   b = ctx->nbits/8;
1113   if (b != 256/8)
1114     return GPG_ERR_INTERNAL; /* We only support 256 bit. */
1115
1116   /* Decode and check the public key.  */
1117   rc = _gcry_ecc_eddsa_decodepoint (pk, ctx, &Q, &encpk, &encpklen);
1118   if (rc)
1119     goto leave;
1120   if (!_gcry_mpi_ec_curve_point (&Q, ctx))
1121     {
1122       rc = GPG_ERR_BROKEN_PUBKEY;
1123       goto leave;
1124     }
1125   if (DBG_CIPHER)
1126     log_printhex ("  e_pk", encpk, encpklen);
1127   if (encpklen != b)
1128     {
1129       rc = GPG_ERR_INV_LENGTH;
1130       goto leave;
1131     }
1132
1133   /* Convert the other input parameters.  */
1134   mbuf = gcry_mpi_get_opaque (input, &tmp);
1135   mlen = (tmp +7)/8;
1136   if (DBG_CIPHER)
1137     log_printhex ("     m", mbuf, mlen);
1138   rbuf = gcry_mpi_get_opaque (r_in, &tmp);
1139   rlen = (tmp +7)/8;
1140   if (DBG_CIPHER)
1141     log_printhex ("     r", rbuf, rlen);
1142   if (rlen != b)
1143     {
1144       rc = GPG_ERR_INV_LENGTH;
1145       goto leave;
1146     }
1147
1148   /* h = H(encodepoint(R) + encodepoint(pk) + m)  */
1149   hvec[0].data = (char*)rbuf;
1150   hvec[0].off  = 0;
1151   hvec[0].len  = rlen;
1152   hvec[1].data = encpk;
1153   hvec[1].off  = 0;
1154   hvec[1].len  = encpklen;
1155   hvec[2].data = (char*)mbuf;
1156   hvec[2].off  = 0;
1157   hvec[2].len  = mlen;
1158   rc = _gcry_md_hash_buffers (hashalgo, 0, digest, hvec, 3);
1159   if (rc)
1160     goto leave;
1161   reverse_buffer (digest, 64);
1162   if (DBG_CIPHER)
1163     log_printhex (" H(R+)", digest, 64);
1164   _gcry_mpi_set_buffer (h, digest, 64, 0);
1165
1166   /* According to the paper the best way for verification is:
1167          encodepoint(sG - h·Q) = encodepoint(r)
1168      because we don't need to decode R. */
1169   {
1170     void *sbuf;
1171     unsigned int slen;
1172
1173     sbuf = _gcry_mpi_get_opaque_copy (s_in, &tmp);
1174     slen = (tmp +7)/8;
1175     reverse_buffer (sbuf, slen);
1176     if (DBG_CIPHER)
1177       log_printhex ("     s", sbuf, slen);
1178     _gcry_mpi_set_buffer (s, sbuf, slen, 0);
1179     gcry_free (sbuf);
1180     if (slen != b)
1181       {
1182         rc = GPG_ERR_INV_LENGTH;
1183         goto leave;
1184       }
1185   }
1186
1187   _gcry_mpi_ec_mul_point (&Ia, s, &pkey->E.G, ctx);
1188   _gcry_mpi_ec_mul_point (&Ib, h, &Q, ctx);
1189   _gcry_mpi_neg (Ib.x, Ib.x);
1190   _gcry_mpi_ec_add_points (&Ia, &Ia, &Ib, ctx);
1191   rc = _gcry_ecc_eddsa_encodepoint (&Ia, ctx, s, h, &tbuf, &tlen);
1192   if (rc)
1193     goto leave;
1194   if (tlen != rlen || memcmp (tbuf, rbuf, tlen))
1195     {
1196       if (DBG_CIPHER)
1197         log_debug ("eddsa verify: Not verified\n");
1198       rc = GPG_ERR_BAD_SIGNATURE;
1199       goto leave;
1200     }
1201
1202   if (DBG_CIPHER)
1203     log_debug ("eddsa verify: Accepted\n");
1204   rc = 0;
1205
1206  leave:
1207   gcry_free (encpk);
1208   gcry_free (tbuf);
1209   _gcry_mpi_ec_free (ctx);
1210   gcry_mpi_release (s);
1211   gcry_mpi_release (h);
1212   point_free (&Ia);
1213   point_free (&Ib);
1214   point_free (&Q);
1215   return rc;
1216 }
1217
1218
1219 \f
1220 /*********************************************
1221  **************  interface  ******************
1222  *********************************************/
1223
1224 static gcry_err_code_t
1225 ecc_generate (int algo, unsigned int nbits, unsigned long evalue,
1226               const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
1227 {
1228   gpg_err_code_t rc;
1229   elliptic_curve_t E;
1230   ECC_secret_key sk;
1231   gcry_mpi_t x = NULL;
1232   gcry_mpi_t y = NULL;
1233   char *curve_name = NULL;
1234   gcry_sexp_t l1;
1235   int transient_key = 0;
1236   gcry_random_level_t random_level;
1237   mpi_ec_t ctx = NULL;
1238   gcry_sexp_t curve_info = NULL;
1239   gcry_mpi_t base = NULL;
1240   gcry_mpi_t public = NULL;
1241   gcry_mpi_t secret = NULL;
1242
1243   (void)algo;
1244   (void)evalue;
1245
1246   memset (&E, 0, sizeof E);
1247   memset (&sk, 0, sizeof sk);
1248
1249   if (genparms)
1250     {
1251       /* Parse the optional "curve" parameter. */
1252       l1 = gcry_sexp_find_token (genparms, "curve", 0);
1253       if (l1)
1254         {
1255           curve_name = _gcry_sexp_nth_string (l1, 1);
1256           gcry_sexp_release (l1);
1257           if (!curve_name)
1258             return GPG_ERR_INV_OBJ; /* No curve name or value too large. */
1259         }
1260
1261       /* Parse the optional transient-key flag.  */
1262       l1 = gcry_sexp_find_token (genparms, "transient-key", 0);
1263       if (l1)
1264         {
1265           transient_key = 1;
1266           gcry_sexp_release (l1);
1267         }
1268     }
1269
1270   /* NBITS is required if no curve name has been given.  */
1271   if (!nbits && !curve_name)
1272     return GPG_ERR_NO_OBJ; /* No NBITS parameter. */
1273
1274   rc = _gcry_ecc_fill_in_curve (nbits, curve_name, &E, &nbits);
1275   gcry_free (curve_name); curve_name = NULL;
1276   if (rc)
1277     goto leave;
1278
1279   if (DBG_CIPHER)
1280     {
1281       log_debug ("ecgen curve info: %s/%s\n",
1282                  _gcry_ecc_model2str (E.model),
1283                  _gcry_ecc_dialect2str (E.dialect));
1284       if (E.name)
1285         log_debug ("ecgen curve used: %s\n", E.name);
1286       log_printmpi ("ecgen curve   p", E.p);
1287       log_printmpi ("ecgen curve   a", E.a);
1288       log_printmpi ("ecgen curve   b", E.b);
1289       log_printmpi ("ecgen curve   n", E.n);
1290       log_printpnt ("ecgen curve G", &E.G, NULL);
1291     }
1292
1293   random_level = transient_key ? GCRY_STRONG_RANDOM : GCRY_VERY_STRONG_RANDOM;
1294   ctx = _gcry_mpi_ec_p_internal_new (E.model, E.dialect, E.p, E.a, E.b);
1295   x = mpi_new (0);
1296   y = mpi_new (0);
1297
1298   switch (E.dialect)
1299     {
1300     case ECC_DIALECT_STANDARD:
1301       rc = nist_generate_key (&sk, &E, ctx, random_level, nbits);
1302       break;
1303     case ECC_DIALECT_ED25519:
1304       rc = eddsa_generate_key (&sk, &E, ctx, random_level);
1305       break;
1306     default:
1307       rc = GPG_ERR_INTERNAL;
1308       break;
1309     }
1310   if (rc)
1311     goto leave;
1312
1313   /* Copy data to the result.  */
1314   if (_gcry_mpi_ec_get_affine (x, y, &sk.E.G, ctx))
1315     log_fatal ("ecgen: Failed to get affine coordinates for %s\n", "G");
1316   base = _gcry_ecc_ec2os (x, y, sk.E.p);
1317   if (sk.E.dialect == ECC_DIALECT_ED25519)
1318     {
1319       unsigned char *encpk;
1320       unsigned int encpklen;
1321
1322       rc = _gcry_ecc_eddsa_encodepoint (&sk.Q, ctx, x, y, &encpk, &encpklen);
1323       if (rc)
1324         return rc;
1325       public = mpi_new (0);
1326       gcry_mpi_set_opaque (public, encpk, encpklen*8);
1327       encpk = NULL;
1328     }
1329   else
1330     {
1331       if (_gcry_mpi_ec_get_affine (x, y, &sk.Q, ctx))
1332         log_fatal ("ecgen: Failed to get affine coordinates for %s\n", "Q");
1333       public = _gcry_ecc_ec2os (x, y, sk.E.p);
1334     }
1335   secret = sk.d; sk.d = NULL;
1336   if (E.name)
1337     {
1338       rc = gcry_sexp_build (&curve_info, NULL, "(curve %s)", E.name);
1339       if (rc)
1340         goto leave;
1341     }
1342
1343   rc = gcry_sexp_build (r_skey, NULL,
1344                         "(key-data"
1345                         " (public-key"
1346                         "  (ecc%S(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))"
1347                         " (private-key"
1348                         "  (ecc%S(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))"
1349                         " )",
1350                         curve_info,
1351                         sk.E.p, sk.E.a, sk.E.b, base, sk.E.n, public,
1352                         curve_info,
1353                         sk.E.p, sk.E.a, sk.E.b, base, sk.E.n, public, secret);
1354   if (rc)
1355     goto leave;
1356
1357   if (DBG_CIPHER)
1358     {
1359       log_printmpi ("ecgen result  p", sk.E.p);
1360       log_printmpi ("ecgen result  a", sk.E.a);
1361       log_printmpi ("ecgen result  b", sk.E.b);
1362       log_printmpi ("ecgen result  G", base);
1363       log_printmpi ("ecgen result  n", sk.E.n);
1364       log_printmpi ("ecgen result  Q", public);
1365       log_printmpi ("ecgen result  d", secret);
1366     }
1367
1368  leave:
1369   mpi_free (secret);
1370   mpi_free (public);
1371   mpi_free (base);
1372   {
1373     _gcry_ecc_curve_free (&sk.E);
1374     point_free (&sk.Q);
1375     mpi_free (sk.d);
1376   }
1377   _gcry_ecc_curve_free (&E);
1378   mpi_free (x);
1379   mpi_free (y);
1380   _gcry_mpi_ec_free (ctx);
1381   gcry_sexp_release (curve_info);
1382   return rc;
1383 }
1384
1385
1386 static gcry_err_code_t
1387 ecc_check_secret_key (int algo, gcry_mpi_t *skey)
1388 {
1389   gpg_err_code_t err;
1390   ECC_secret_key sk;
1391
1392   (void)algo;
1393
1394   /* FIXME:  This check looks a bit fishy:  Now long is the array?  */
1395   if (!skey[0] || !skey[1] || !skey[2] || !skey[3] || !skey[4] || !skey[5]
1396       || !skey[6])
1397     return GPG_ERR_BAD_MPI;
1398
1399   sk.E.model = MPI_EC_WEIERSTRASS;
1400   sk.E.p = skey[0];
1401   sk.E.a = skey[1];
1402   sk.E.b = skey[2];
1403   point_init (&sk.E.G);
1404   err = _gcry_ecc_os2ec (&sk.E.G, skey[3]);
1405   if (err)
1406     {
1407       point_free (&sk.E.G);
1408       return err;
1409     }
1410   sk.E.n = skey[4];
1411   point_init (&sk.Q);
1412   err = _gcry_ecc_os2ec (&sk.Q, skey[5]);
1413   if (err)
1414     {
1415       point_free (&sk.E.G);
1416       point_free (&sk.Q);
1417       return err;
1418     }
1419
1420   {
1421     const unsigned char *buf;
1422     unsigned int n;
1423
1424     gcry_assert (mpi_is_opaque (skey[6]));
1425
1426     buf = gcry_mpi_get_opaque (skey[6], &n);
1427     if (!buf)
1428       err = GPG_ERR_INV_OBJ;
1429     else
1430       {
1431         n = (n + 7)/8;
1432         sk.d = NULL;
1433         err = gcry_mpi_scan (&sk.d, GCRYMPI_FMT_USG, buf, n, NULL);
1434         if (!err)
1435           {
1436             if (check_secret_key (&sk))
1437               err = GPG_ERR_BAD_SECKEY;
1438             gcry_mpi_release (sk.d);
1439             sk.d = NULL;
1440           }
1441       }
1442   }
1443
1444   point_free (&sk.E.G);
1445   point_free (&sk.Q);
1446   return err;
1447 }
1448
1449
1450 static gcry_err_code_t
1451 ecc_sign (int algo, gcry_sexp_t *r_result, gcry_mpi_t data, gcry_mpi_t *skey,
1452           int flags, int hashalgo)
1453 {
1454   gpg_err_code_t rc;
1455   ECC_secret_key sk;
1456   gcry_mpi_t r, s;
1457
1458   (void)algo;
1459
1460   if (!data || !skey[0] || !skey[1] || !skey[2] || !skey[3] || !skey[4]
1461       || !skey[6] )
1462     return GPG_ERR_BAD_MPI;
1463
1464   /* FIXME: The setting of model and dialect are crude hacks.  We will
1465      fix that by moving the s-expression parsing from pubkey.c to
1466      here.  */
1467   sk.E.model = ((flags & PUBKEY_FLAG_EDDSA)
1468                 ? MPI_EC_TWISTEDEDWARDS
1469                 : MPI_EC_WEIERSTRASS);
1470   sk.E.dialect = ((flags & PUBKEY_FLAG_EDDSA)
1471                   ? ECC_DIALECT_ED25519
1472                   : ECC_DIALECT_STANDARD);
1473   sk.E.p = skey[0];
1474   sk.E.a = skey[1];
1475   sk.E.b = skey[2];
1476   point_init (&sk.E.G);
1477   sk.Q.x = NULL;
1478   sk.Q.y = NULL;
1479   sk.Q.z = NULL;
1480   rc = _gcry_ecc_os2ec (&sk.E.G, skey[3]);
1481   if (rc)
1482     {
1483       point_free (&sk.E.G);
1484       return rc;
1485     }
1486   sk.E.n = skey[4];
1487
1488   r = mpi_alloc (mpi_get_nlimbs (sk.E.p));
1489   s = mpi_alloc (mpi_get_nlimbs (sk.E.p));
1490
1491   {
1492     const unsigned char *buf;
1493     unsigned int n;
1494
1495     gcry_assert (mpi_is_opaque (skey[6]));
1496
1497     buf = gcry_mpi_get_opaque (skey[6], &n);
1498     if (!buf)
1499       rc = GPG_ERR_INV_OBJ;
1500     else
1501       {
1502         n = (n + 7)/8;
1503         sk.d = NULL;
1504         rc = gcry_mpi_scan (&sk.d, GCRYMPI_FMT_USG, buf, n, NULL);
1505         if (!rc)
1506           {
1507             if ((flags & PUBKEY_FLAG_EDDSA))
1508               {
1509                 rc = sign_eddsa (data, &sk, r, s, hashalgo, skey[5]);
1510                 if (!rc)
1511                   rc = gcry_sexp_build (r_result, NULL,
1512                                         "(sig-val(eddsa(r%M)(s%M)))", r, s);
1513               }
1514             else
1515               {
1516                 rc = sign_ecdsa (data, &sk, r, s, flags, hashalgo);
1517                 if (!rc)
1518                   rc = gcry_sexp_build (r_result, NULL,
1519                                         "(sig-val(ecdsa(r%M)(s%M)))", r, s);
1520               }
1521             gcry_mpi_release (sk.d);
1522             sk.d = NULL;
1523           }
1524       }
1525   }
1526
1527   mpi_free (r);
1528   mpi_free (s);
1529   point_free (&sk.E.G);
1530   if (sk.Q.x)
1531     point_free (&sk.Q);
1532   return rc;
1533 }
1534
1535
1536 static gcry_err_code_t
1537 ecc_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
1538             int (*cmp)(void *, gcry_mpi_t), void *opaquev,
1539             int flags, int hashalgo)
1540 {
1541   gpg_err_code_t err;
1542   ECC_public_key pk;
1543
1544   (void)algo;
1545   (void)cmp;
1546   (void)opaquev;
1547
1548   if (!data[0] || !data[1] || !hash || !pkey[0] || !pkey[1] || !pkey[2]
1549       || !pkey[3] || !pkey[4] || !pkey[5] )
1550     return GPG_ERR_BAD_MPI;
1551
1552   /* FIXME: The setting of model and dialect are crude hacks.  We will
1553      fix that by moving the s-expression parsing from pubkey.c to
1554      here.  */
1555   pk.E.model = ((flags & PUBKEY_FLAG_EDDSA)
1556                 ? MPI_EC_TWISTEDEDWARDS
1557                 : MPI_EC_WEIERSTRASS);
1558   pk.E.dialect = ((flags & PUBKEY_FLAG_EDDSA)
1559                   ? ECC_DIALECT_ED25519
1560                   : ECC_DIALECT_STANDARD);
1561   pk.E.p = pkey[0];
1562   pk.E.a = pkey[1];
1563   pk.E.b = pkey[2];
1564   point_init (&pk.E.G);
1565   err = _gcry_ecc_os2ec (&pk.E.G, pkey[3]);
1566   if (err)
1567     {
1568       point_free (&pk.E.G);
1569       return err;
1570     }
1571   pk.E.n = pkey[4];
1572
1573   if ((flags & PUBKEY_FLAG_EDDSA))
1574     {
1575       pk.Q.x = NULL;
1576       pk.Q.y = NULL;
1577       pk.Q.z = NULL;
1578
1579       err = verify_eddsa (hash, &pk, data[0], data[1], hashalgo, pkey[5]);
1580     }
1581   else
1582     {
1583       point_init (&pk.Q);
1584       err = _gcry_ecc_os2ec (&pk.Q, pkey[5]);
1585       if (err)
1586         {
1587           point_free (&pk.E.G);
1588           point_free (&pk.Q);
1589           return err;
1590         }
1591
1592       if (mpi_is_opaque (hash))
1593         {
1594           const void *abuf;
1595           unsigned int abits, qbits;
1596           gcry_mpi_t a;
1597
1598           qbits = mpi_get_nbits (pk.E.n);
1599
1600           abuf = gcry_mpi_get_opaque (hash, &abits);
1601           err = gcry_mpi_scan (&a, GCRYMPI_FMT_USG, abuf, (abits+7)/8, NULL);
1602           if (!err)
1603             {
1604               if (abits > qbits)
1605                 gcry_mpi_rshift (a, a, abits - qbits);
1606
1607               err = verify_ecdsa (a, &pk, data[0], data[1]);
1608               gcry_mpi_release (a);
1609             }
1610         }
1611       else
1612         err = verify_ecdsa (hash, &pk, data[0], data[1]);
1613     }
1614
1615   point_free (&pk.E.G);
1616   point_free (&pk.Q);
1617   return err;
1618 }
1619
1620
1621 /* ecdh raw is classic 2-round DH protocol published in 1976.
1622  *
1623  * Overview of ecc_encrypt_raw and ecc_decrypt_raw.
1624  *
1625  * As with any PK operation, encrypt version uses a public key and
1626  * decrypt -- private.
1627  *
1628  * Symbols used below:
1629  *     G - field generator point
1630  *     d - private long-term scalar
1631  *    dG - public long-term key
1632  *     k - ephemeral scalar
1633  *    kG - ephemeral public key
1634  *   dkG - shared secret
1635  *
1636  * ecc_encrypt_raw description:
1637  *   input:
1638  *     data[0] : private scalar (k)
1639  *   output: A new S-expression with the parameters:
1640  *     s : shared point (kdG)
1641  *     e : generated ephemeral public key (kG)
1642  *
1643  * ecc_decrypt_raw description:
1644  *   input:
1645  *     data[0] : a point kG (ephemeral public key)
1646  *   output:
1647  *     result[0] : shared point (kdG)
1648  */
1649 static gcry_err_code_t
1650 ecc_encrypt_raw (int algo, gcry_sexp_t *r_result, gcry_mpi_t k,
1651                  gcry_mpi_t *pkey, int flags)
1652 {
1653   gpg_err_code_t rc;
1654   ECC_public_key pk;
1655   mpi_ec_t ctx;
1656   gcry_mpi_t s, e;
1657
1658   (void)algo;
1659   (void)flags;
1660
1661   if (!k
1662       || !pkey[0] || !pkey[1] || !pkey[2] || !pkey[3] || !pkey[4] || !pkey[5])
1663     return GPG_ERR_BAD_MPI;
1664
1665   pk.E.model = MPI_EC_WEIERSTRASS;
1666   pk.E.p = pkey[0];
1667   pk.E.a = pkey[1];
1668   pk.E.b = pkey[2];
1669   point_init (&pk.E.G);
1670   rc = _gcry_ecc_os2ec (&pk.E.G, pkey[3]);
1671   if (rc)
1672     {
1673       point_free (&pk.E.G);
1674       return rc;
1675     }
1676   pk.E.n = pkey[4];
1677   point_init (&pk.Q);
1678   rc = _gcry_ecc_os2ec (&pk.Q, pkey[5]);
1679   if (rc)
1680     {
1681       point_free (&pk.E.G);
1682       point_free (&pk.Q);
1683       return rc;
1684     }
1685
1686   ctx = _gcry_mpi_ec_p_internal_new (pk.E.model, pk.E.dialect,
1687                                      pk.E.p, pk.E.a, pk.E.b);
1688   s = mpi_alloc (mpi_get_nlimbs (pk.E.p));
1689   e = mpi_alloc (mpi_get_nlimbs (pk.E.p));
1690
1691   /* The following is false: assert( mpi_cmp_ui( R.x, 1 )==0 );, so */
1692   {
1693     mpi_point_struct R;  /* Result that we return.  */
1694     gcry_mpi_t x, y;
1695
1696     x = mpi_new (0);
1697     y = mpi_new (0);
1698
1699     point_init (&R);
1700
1701     /* R = kQ  <=>  R = kdG  */
1702     _gcry_mpi_ec_mul_point (&R, k, &pk.Q, ctx);
1703
1704     if (_gcry_mpi_ec_get_affine (x, y, &R, ctx))
1705       log_fatal ("ecdh: Failed to get affine coordinates for kdG\n");
1706     s = _gcry_ecc_ec2os (x, y, pk.E.p);
1707
1708     /* R = kG */
1709     _gcry_mpi_ec_mul_point (&R, k, &pk.E.G, ctx);
1710
1711     if (_gcry_mpi_ec_get_affine (x, y, &R, ctx))
1712       log_fatal ("ecdh: Failed to get affine coordinates for kG\n");
1713     e = _gcry_ecc_ec2os (x, y, pk.E.p);
1714
1715     mpi_free (x);
1716     mpi_free (y);
1717
1718     point_free (&R);
1719   }
1720
1721   _gcry_mpi_ec_free (ctx);
1722   point_free (&pk.E.G);
1723   point_free (&pk.Q);
1724
1725   rc = gcry_sexp_build (r_result, NULL, "(enc-val(ecdh(s%m)(e%m)))", s, e);
1726   mpi_free (s);
1727   mpi_free (e);
1728
1729   return rc;
1730 }
1731
1732 /*  input:
1733  *     data[0] : a point kG (ephemeral public key)
1734  *   output:
1735  *     resaddr[0] : shared point kdG
1736  *
1737  *  see ecc_encrypt_raw for details.
1738  */
1739 static gcry_err_code_t
1740 ecc_decrypt_raw (int algo, gcry_sexp_t *r_plain, gcry_mpi_t *data,
1741                  gcry_mpi_t *skey, int flags,
1742                  enum pk_encoding encoding, int hash_algo,
1743                  unsigned char *label, size_t labellen)
1744 {
1745   gpg_err_code_t rc;
1746   ECC_secret_key sk;
1747   mpi_point_struct R;   /* Result that we return.  */
1748   mpi_point_struct kG;
1749   mpi_ec_t ctx;
1750   gcry_mpi_t r;
1751
1752   (void)algo;
1753   (void)flags;
1754   (void)encoding;
1755   (void)hash_algo;
1756   (void)label;
1757   (void)labellen;
1758
1759   if (!data || !data[0]
1760       || !skey[0] || !skey[1] || !skey[2] || !skey[3] || !skey[4]
1761       || !skey[5] || !skey[6] )
1762     return GPG_ERR_BAD_MPI;
1763
1764   point_init (&kG);
1765   rc = _gcry_ecc_os2ec (&kG, data[0]);
1766   if (rc)
1767     {
1768       point_free (&kG);
1769       return rc;
1770     }
1771
1772   sk.E.model = MPI_EC_WEIERSTRASS;
1773   sk.E.p = skey[0];
1774   sk.E.a = skey[1];
1775   sk.E.b = skey[2];
1776   point_init (&sk.E.G);
1777   rc = _gcry_ecc_os2ec (&sk.E.G, skey[3]);
1778   if (rc)
1779     {
1780       point_free (&kG);
1781       point_free (&sk.E.G);
1782       return rc;
1783     }
1784   sk.E.n = skey[4];
1785   point_init (&sk.Q);
1786   rc = _gcry_ecc_os2ec (&sk.Q, skey[5]);
1787   if (rc)
1788     {
1789       point_free (&kG);
1790       point_free (&sk.E.G);
1791       point_free (&sk.Q);
1792       return rc;
1793     }
1794   sk.d = skey[6];
1795
1796   ctx = _gcry_mpi_ec_p_internal_new (sk.E.model, sk.E.dialect,
1797                                      sk.E.p, sk.E.a, sk.E.b);
1798
1799   /* R = dkG */
1800   point_init (&R);
1801   _gcry_mpi_ec_mul_point (&R, sk.d, &kG, ctx);
1802
1803   point_free (&kG);
1804
1805   /* The following is false: assert( mpi_cmp_ui( R.x, 1 )==0 );, so:  */
1806   {
1807     gcry_mpi_t x, y;
1808
1809     x = mpi_new (0);
1810     y = mpi_new (0);
1811
1812     if (_gcry_mpi_ec_get_affine (x, y, &R, ctx))
1813       log_fatal ("ecdh: Failed to get affine coordinates\n");
1814
1815     r = _gcry_ecc_ec2os (x, y, sk.E.p);
1816     if (!r)
1817       rc = gpg_err_code_from_syserror ();
1818     else
1819       rc = 0;
1820     mpi_free (x);
1821     mpi_free (y);
1822   }
1823
1824   point_free (&R);
1825   _gcry_mpi_ec_free (ctx);
1826   point_free (&kG);
1827   point_free (&sk.E.G);
1828   point_free (&sk.Q);
1829
1830   if (!rc)
1831     rc = gcry_sexp_build (r_plain, NULL, "(value %m)", r);
1832   mpi_free (r);
1833   return rc;
1834 }
1835
1836
1837 static unsigned int
1838 ecc_get_nbits (int algo, gcry_mpi_t *pkey)
1839 {
1840   (void)algo;
1841
1842   return mpi_get_nbits (pkey[0]);
1843 }
1844
1845
1846 /* See rsa.c for a description of this function.  */
1847 static gpg_err_code_t
1848 compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparam)
1849 {
1850 #define N_COMPONENTS 6
1851   static const char names[N_COMPONENTS+1] = "pabgnq";
1852   gpg_err_code_t ec = 0;
1853   gcry_sexp_t l1;
1854   gcry_mpi_t values[N_COMPONENTS];
1855   int idx;
1856
1857   /* Clear the values for easier error cleanup.  */
1858   for (idx=0; idx < N_COMPONENTS; idx++)
1859     values[idx] = NULL;
1860
1861   /* Fill values with all provided parameters.  */
1862   for (idx=0; idx < N_COMPONENTS; idx++)
1863     {
1864       l1 = gcry_sexp_find_token (keyparam, names+idx, 1);
1865       if (l1)
1866         {
1867           values[idx] = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
1868           gcry_sexp_release (l1);
1869           if (!values[idx])
1870             {
1871               ec = GPG_ERR_INV_OBJ;
1872               goto leave;
1873             }
1874         }
1875     }
1876
1877   /* Check whether a curve parameter is available and use that to fill
1878      in missing values.  */
1879   l1 = gcry_sexp_find_token (keyparam, "curve", 5);
1880   if (l1)
1881     {
1882       char *curve;
1883       gcry_mpi_t tmpvalues[N_COMPONENTS];
1884
1885       for (idx = 0; idx < N_COMPONENTS; idx++)
1886         tmpvalues[idx] = NULL;
1887
1888       curve = _gcry_sexp_nth_string (l1, 1);
1889       gcry_sexp_release (l1);
1890       if (!curve)
1891         {
1892           ec = GPG_ERR_INV_OBJ; /* Name missing or out of core. */
1893           goto leave;
1894         }
1895       ec = _gcry_ecc_get_param (curve, tmpvalues);
1896       gcry_free (curve);
1897       if (ec)
1898         goto leave;
1899
1900       for (idx = 0; idx < N_COMPONENTS; idx++)
1901         {
1902           if (!values[idx])
1903             values[idx] = tmpvalues[idx];
1904           else
1905             mpi_free (tmpvalues[idx]);
1906         }
1907     }
1908
1909   /* Check that all parameters are known and normalize all MPIs (that
1910      should not be required but we use an internal function later and
1911      thus we better make 100% sure that they are normalized). */
1912   for (idx = 0; idx < N_COMPONENTS; idx++)
1913     if (!values[idx])
1914       {
1915         ec = GPG_ERR_NO_OBJ;
1916         goto leave;
1917       }
1918     else
1919       _gcry_mpi_normalize (values[idx]);
1920
1921   /* Hash them all.  */
1922   for (idx = 0; idx < N_COMPONENTS; idx++)
1923     {
1924       char buf[30];
1925       unsigned char *rawmpi;
1926       unsigned int rawmpilen;
1927
1928       rawmpi = _gcry_mpi_get_buffer (values[idx], 0, &rawmpilen, NULL);
1929       if (!rawmpi)
1930         {
1931           ec = gpg_err_code_from_syserror ();
1932           goto leave;
1933         }
1934       snprintf (buf, sizeof buf, "(1:%c%u:", names[idx], rawmpilen);
1935       gcry_md_write (md, buf, strlen (buf));
1936       gcry_md_write (md, rawmpi, rawmpilen);
1937       gcry_md_write (md, ")", 1);
1938       gcry_free (rawmpi);
1939     }
1940
1941  leave:
1942   for (idx = 0; idx < N_COMPONENTS; idx++)
1943     _gcry_mpi_release (values[idx]);
1944
1945   return ec;
1946 #undef N_COMPONENTS
1947 }
1948
1949
1950 \f
1951 /*
1952    Low-level API helper functions.
1953  */
1954
1955 /* This is the worker function for gcry_pubkey_get_sexp for ECC
1956    algorithms.  Note that the caller has already stored NULL at
1957    R_SEXP.  */
1958 gpg_err_code_t
1959 _gcry_pk_ecc_get_sexp (gcry_sexp_t *r_sexp, int mode, mpi_ec_t ec)
1960 {
1961   gpg_err_code_t rc;
1962   gcry_mpi_t mpi_G = NULL;
1963   gcry_mpi_t mpi_Q = NULL;
1964
1965   if (!ec->p || !ec->a || !ec->b || !ec->G || !ec->n)
1966     return GPG_ERR_BAD_CRYPT_CTX;
1967
1968   if (mode == GCRY_PK_GET_SECKEY && !ec->d)
1969     return GPG_ERR_NO_SECKEY;
1970
1971   /* Compute the public point if it is missing.  */
1972   if (!ec->Q && ec->d)
1973     ec->Q = _gcry_ecc_compute_public (NULL, ec);
1974
1975   /* Encode G and Q.  */
1976   mpi_G = _gcry_mpi_ec_ec2os (ec->G, ec);
1977   if (!mpi_G)
1978     {
1979       rc = GPG_ERR_BROKEN_PUBKEY;
1980       goto leave;
1981     }
1982   if (!ec->Q)
1983     {
1984       rc = GPG_ERR_BAD_CRYPT_CTX;
1985       goto leave;
1986     }
1987
1988   if (ec->dialect == ECC_DIALECT_ED25519)
1989     {
1990       unsigned char *encpk;
1991       unsigned int encpklen;
1992
1993       rc = _gcry_ecc_eddsa_encodepoint (ec->Q, ec, NULL, NULL,
1994                                         &encpk, &encpklen);
1995       if (rc)
1996         goto leave;
1997       mpi_Q = gcry_mpi_set_opaque (NULL, encpk, encpklen*8);
1998       encpk = NULL;
1999     }
2000   else
2001     {
2002       mpi_Q = _gcry_mpi_ec_ec2os (ec->Q, ec);
2003     }
2004   if (!mpi_Q)
2005     {
2006       rc = GPG_ERR_BROKEN_PUBKEY;
2007       goto leave;
2008     }
2009
2010   /* Fixme: We should return a curve name instead of the parameters if
2011      if know that they match a curve.  */
2012
2013   if (ec->d && (!mode || mode == GCRY_PK_GET_SECKEY))
2014     {
2015       /* Let's return a private key. */
2016       rc = gcry_sexp_build
2017         (r_sexp, NULL,
2018          "(private-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))",
2019          ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q, ec->d);
2020     }
2021   else if (ec->Q)
2022     {
2023       /* Let's return a public key.  */
2024       rc = gcry_sexp_build
2025         (r_sexp, NULL,
2026          "(public-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))",
2027          ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q);
2028     }
2029   else
2030     rc = GPG_ERR_BAD_CRYPT_CTX;
2031
2032  leave:
2033   mpi_free (mpi_Q);
2034   mpi_free (mpi_G);
2035   return rc;
2036 }
2037
2038
2039 \f
2040 /*
2041      Self-test section.
2042  */
2043
2044
2045 static gpg_err_code_t
2046 selftests_ecdsa (selftest_report_func_t report)
2047 {
2048   const char *what;
2049   const char *errtxt;
2050
2051   what = "low-level";
2052   errtxt = NULL; /*selftest ();*/
2053   if (errtxt)
2054     goto failed;
2055
2056   /* FIXME:  need more tests.  */
2057
2058   return 0; /* Succeeded. */
2059
2060  failed:
2061   if (report)
2062     report ("pubkey", GCRY_PK_ECC, what, errtxt);
2063   return GPG_ERR_SELFTEST_FAILED;
2064 }
2065
2066
2067 /* Run a full self-test for ALGO and return 0 on success.  */
2068 static gpg_err_code_t
2069 run_selftests (int algo, int extended, selftest_report_func_t report)
2070 {
2071   (void)extended;
2072
2073   if (algo != GCRY_PK_ECC)
2074     return GPG_ERR_PUBKEY_ALGO;
2075
2076   return selftests_ecdsa (report);
2077 }
2078
2079
2080
2081 \f
2082 static const char *ecc_names[] =
2083   {
2084     "ecc",
2085     "ecdsa",
2086     "ecdh",
2087     "eddsa",
2088     NULL,
2089   };
2090
2091 gcry_pk_spec_t _gcry_pubkey_spec_ecc =
2092   {
2093     GCRY_PK_ECC, { 0, 0 },
2094     (GCRY_PK_USAGE_SIGN | GCRY_PK_USAGE_ENCR),
2095     "ECC", ecc_names,
2096     "pabgnq", "pabgnqd", "sw", "rs", "pabgnq",
2097     ecc_generate,
2098     ecc_check_secret_key,
2099     ecc_encrypt_raw,
2100     ecc_decrypt_raw,
2101     ecc_sign,
2102     ecc_verify,
2103     ecc_get_nbits,
2104     run_selftests,
2105     compute_keygrip,
2106     _gcry_ecc_get_param,
2107     _gcry_ecc_get_curve,
2108     _gcry_ecc_get_param_sexp
2109   };