5c898cc612ab7fe7c71a8e39d18620cb1cc745b2
[gnupg.git] / g10 / keygen.c
1 /* keygen.c - generate a key pair
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3  *               2007, 2009, 2010, 2011  Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG 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 General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26 #include <errno.h>
27 #include <assert.h>
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <unistd.h>
31
32 #include "gpg.h"
33 #include "util.h"
34 #include "main.h"
35 #include "packet.h"
36 #include "ttyio.h"
37 #include "options.h"
38 #include "keydb.h"
39 #include "trustdb.h"
40 #include "status.h"
41 #include "i18n.h"
42 #include "keyserver-internal.h"
43 #include "call-agent.h"
44 #include "pkglue.h"
45
46 /* The default algorithms.  If you change them remember to change them
47    also in gpg.c:gpgconf_list.  You should also check that the value
48    is inside the bounds enforced by ask_keysize and gen_xxx.  */
49 #define DEFAULT_STD_ALGO    GCRY_PK_RSA
50 #define DEFAULT_STD_KEYSIZE 2048
51
52 /* Flag bits used during key generation.  */
53 #define KEYGEN_FLAG_NO_PROTECTION 1
54 #define KEYGEN_FLAG_TRANSIENT_KEY 2
55
56 /* Maximum number of supported algorithm preferences.  */
57 #define MAX_PREFS 30
58
59 enum para_name {
60   pKEYTYPE,
61   pKEYLENGTH,
62   pKEYCURVE,
63   pKEYUSAGE,
64   pSUBKEYTYPE,
65   pSUBKEYLENGTH,
66   pSUBKEYCURVE,
67   pSUBKEYUSAGE,
68   pAUTHKEYTYPE,
69   pNAMEREAL,
70   pNAMEEMAIL,
71   pNAMECOMMENT,
72   pPREFERENCES,
73   pREVOKER,
74   pUSERID,
75   pCREATIONDATE,
76   pKEYCREATIONDATE, /* Same in seconds since epoch.  */
77   pEXPIREDATE,
78   pKEYEXPIRE, /* in n seconds */
79   pSUBKEYEXPIRE, /* in n seconds */
80   pPASSPHRASE,
81   pPASSPHRASE_DEK,
82   pPASSPHRASE_S2K,
83   pSERIALNO,
84   pCARDBACKUPKEY,
85   pHANDLE,
86   pKEYSERVER
87 };
88
89 struct para_data_s {
90     struct para_data_s *next;
91     int lnr;
92     enum para_name key;
93     union {
94         DEK *dek;
95         STRING2KEY *s2k;
96         u32 expire;
97         u32 creation;
98         unsigned int usage;
99         struct revocation_key revkey;
100         char value[1];
101     } u;
102 };
103
104 struct output_control_s
105 {
106   int lnr;
107   int dryrun;
108   int ask_passphrase;
109   unsigned int keygen_flags;
110   int use_files;
111   struct {
112     char  *fname;
113     char  *newfname;
114     IOBUF stream;
115     armor_filter_context_t *afx;
116   } pub;
117 };
118
119
120 struct opaque_data_usage_and_pk {
121     unsigned int usage;
122     PKT_public_key *pk;
123 };
124
125
126 static int prefs_initialized = 0;
127 static byte sym_prefs[MAX_PREFS];
128 static int nsym_prefs;
129 static byte hash_prefs[MAX_PREFS];
130 static int nhash_prefs;
131 static byte zip_prefs[MAX_PREFS];
132 static int nzip_prefs;
133 static int mdc_available,ks_modify;
134
135 static void do_generate_keypair( struct para_data_s *para,
136                                  struct output_control_s *outctrl, int card );
137 static int write_keyblock (iobuf_t out, kbnode_t node);
138 static gpg_error_t gen_card_key (int algo, int keyno, int is_primary,
139                                  kbnode_t pub_root,
140                                  u32 *timestamp, u32 expireval);
141 static int gen_card_key_with_backup (int algo, int keyno, int is_primary,
142                                      kbnode_t pub_root, u32 timestamp,
143                                      u32 expireval, struct para_data_s *para);
144
145
146 static void
147 print_status_key_created (int letter, PKT_public_key *pk, const char *handle)
148 {
149   byte array[MAX_FINGERPRINT_LEN], *s;
150   char *buf, *p;
151   size_t i, n;
152
153   if (!handle)
154     handle = "";
155
156   buf = xmalloc (MAX_FINGERPRINT_LEN*2+31 + strlen (handle) + 1);
157
158   p = buf;
159   if (letter || pk)
160     {
161       *p++ = letter;
162       *p++ = ' ';
163       fingerprint_from_pk (pk, array, &n);
164       s = array;
165       for (i=0; i < n ; i++, s++, p += 2)
166         sprintf (p, "%02X", *s);
167     }
168   if (*handle)
169     {
170       *p++ = ' ';
171       for (i=0; handle[i] && i < 100; i++)
172         *p++ = isspace ((unsigned int)handle[i])? '_':handle[i];
173     }
174   *p = 0;
175   write_status_text ((letter || pk)?STATUS_KEY_CREATED:STATUS_KEY_NOT_CREATED,
176                      buf);
177   xfree (buf);
178 }
179
180 static void
181 print_status_key_not_created (const char *handle)
182 {
183   print_status_key_created (0, NULL, handle);
184 }
185
186
187
188 static void
189 write_uid( KBNODE root, const char *s )
190 {
191     PACKET *pkt = xmalloc_clear(sizeof *pkt );
192     size_t n = strlen(s);
193
194     pkt->pkttype = PKT_USER_ID;
195     pkt->pkt.user_id = xmalloc_clear( sizeof *pkt->pkt.user_id + n - 1 );
196     pkt->pkt.user_id->len = n;
197     pkt->pkt.user_id->ref = 1;
198     strcpy(pkt->pkt.user_id->name, s);
199     add_kbnode( root, new_kbnode( pkt ) );
200 }
201
202 static void
203 do_add_key_flags (PKT_signature *sig, unsigned int use)
204 {
205     byte buf[1];
206
207     buf[0] = 0;
208
209     /* The spec says that all primary keys MUST be able to certify. */
210     if(sig->sig_class!=0x18)
211       buf[0] |= 0x01;
212
213     if (use & PUBKEY_USAGE_SIG)
214       buf[0] |= 0x02;
215     if (use & PUBKEY_USAGE_ENC)
216         buf[0] |= 0x04 | 0x08;
217     if (use & PUBKEY_USAGE_AUTH)
218         buf[0] |= 0x20;
219
220     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, 1);
221 }
222
223
224 int
225 keygen_add_key_expire (PKT_signature *sig, void *opaque)
226 {
227   PKT_public_key *pk = opaque;
228   byte buf[8];
229   u32  u;
230
231   if (pk->expiredate)
232     {
233       if (pk->expiredate > pk->timestamp)
234         u = pk->expiredate - pk->timestamp;
235       else
236         u = 1;
237
238       buf[0] = (u >> 24) & 0xff;
239       buf[1] = (u >> 16) & 0xff;
240       buf[2] = (u >>    8) & 0xff;
241       buf[3] = u & 0xff;
242       build_sig_subpkt (sig, SIGSUBPKT_KEY_EXPIRE, buf, 4);
243     }
244   else
245     {
246       /* Make sure we don't leave a key expiration subpacket lying
247          around */
248       delete_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE);
249     }
250
251   return 0;
252 }
253
254
255 static int
256 keygen_add_key_flags_and_expire (PKT_signature *sig, void *opaque)
257 {
258   struct opaque_data_usage_and_pk *oduap = opaque;
259
260   do_add_key_flags (sig, oduap->usage);
261   return keygen_add_key_expire (sig, oduap->pk);
262 }
263
264
265 static int
266 set_one_pref (int val, int type, const char *item, byte *buf, int *nbuf)
267 {
268     int i;
269
270     for (i=0; i < *nbuf; i++ )
271       if (buf[i] == val)
272         {
273           log_info (_("preference '%s' duplicated\n"), item);
274           return -1;
275         }
276
277     if (*nbuf >= MAX_PREFS)
278       {
279         if(type==1)
280           log_info(_("too many cipher preferences\n"));
281         else if(type==2)
282           log_info(_("too many digest preferences\n"));
283         else if(type==3)
284           log_info(_("too many compression preferences\n"));
285         else
286           BUG();
287
288         return -1;
289       }
290
291     buf[(*nbuf)++] = val;
292     return 0;
293 }
294
295 /*
296  * Parse the supplied string and use it to set the standard
297  * preferences.  The string may be in a form like the one printed by
298  * "pref" (something like: "S10 S3 H3 H2 Z2 Z1") or the actual
299  * cipher/hash/compress names.  Use NULL to set the default
300  * preferences.  Returns: 0 = okay
301  */
302 int
303 keygen_set_std_prefs (const char *string,int personal)
304 {
305     byte sym[MAX_PREFS], hash[MAX_PREFS], zip[MAX_PREFS];
306     int nsym=0, nhash=0, nzip=0, val, rc=0;
307     int mdc=1, modify=0; /* mdc defaults on, modify defaults off. */
308     char dummy_string[20*4+1]; /* Enough for 20 items. */
309
310     if (!string || !ascii_strcasecmp (string, "default"))
311       {
312         if (opt.def_preference_list)
313           string=opt.def_preference_list;
314         else
315           {
316             int any_compress = 0;
317             dummy_string[0]='\0';
318
319             /* The rationale why we use the order AES256,192,128 is
320                for compatibility reasons with PGP.  If gpg would
321                define AES128 first, we would get the somewhat
322                confusing situation:
323
324                  gpg -r pgpkey -r gpgkey  ---gives--> AES256
325                  gpg -r gpgkey -r pgpkey  ---gives--> AES
326
327                Note that by using --personal-cipher-preferences it is
328                possible to prefer AES128.
329             */
330
331             /* Make sure we do not add more than 15 items here, as we
332                could overflow the size of dummy_string.  We currently
333                have at most 12. */
334             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES256) )
335               strcat(dummy_string,"S9 ");
336             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES192) )
337               strcat(dummy_string,"S8 ");
338             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES) )
339               strcat(dummy_string,"S7 ");
340             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_CAST5) )
341               strcat(dummy_string,"S3 ");
342             strcat(dummy_string,"S2 "); /* 3DES */
343             /* If we have it, IDEA goes *after* 3DES so it won't be
344                used unless we're encrypting along with a V3 key.
345                Ideally, we would only put the S1 preference in if the
346                key was RSA and <=2048 bits, as that is what won't
347                break PGP2, but that is difficult with the current
348                code, and not really worth checking as a non-RSA <=2048
349                bit key wouldn't be usable by PGP2 anyway. -dms */
350             if (PGP2 && !openpgp_cipher_test_algo (CIPHER_ALGO_IDEA) )
351               strcat(dummy_string,"S1 ");
352
353
354             /* The default hash algo order is:
355                  SHA-256, SHA-1, SHA-384, SHA-512, SHA-224.
356                Ordering SHA-1 before SHA-384 might be viewed as a bit
357                strange; it is done because we expect that soon enough
358                SHA-3 will be available and at that point there should
359                be no more need for SHA-384 etc.  Anyway this order is
360                just a default and can easily be changed by a config
361                option.  */
362             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA256))
363               strcat (dummy_string, "H8 ");
364
365             strcat (dummy_string, "H2 "); /* SHA-1 */
366
367             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA384))
368               strcat (dummy_string, "H9 ");
369
370             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA512))
371               strcat (dummy_string, "H10 ");
372
373             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA224))
374               strcat (dummy_string, "H11 ");
375
376             if(!check_compress_algo(COMPRESS_ALGO_ZLIB))
377               {
378                 strcat(dummy_string,"Z2 ");
379                 any_compress = 1;
380               }
381
382             if(!check_compress_algo(COMPRESS_ALGO_BZIP2))
383               {
384                 strcat(dummy_string,"Z3 ");
385                 any_compress = 1;
386               }
387
388             if(!check_compress_algo(COMPRESS_ALGO_ZIP))
389               {
390                 strcat(dummy_string,"Z1 ");
391                 any_compress = 1;
392               }
393
394             /* In case we have no compress algo at all, declare that
395                we prefer no compresssion.  */
396             if (!any_compress)
397               strcat(dummy_string,"Z0 ");
398
399             /* Remove the trailing space.  */
400             if (*dummy_string && dummy_string[strlen (dummy_string)-1] == ' ')
401               dummy_string[strlen (dummy_string)-1] = 0;
402
403             string=dummy_string;
404           }
405       }
406     else if (!ascii_strcasecmp (string, "none"))
407         string = "";
408
409     if(strlen(string))
410       {
411         char *tok,*prefstring;
412
413         prefstring=xstrdup(string); /* need a writable string! */
414
415         while((tok=strsep(&prefstring," ,")))
416           {
417             if((val=string_to_cipher_algo (tok)))
418               {
419                 if(set_one_pref(val,1,tok,sym,&nsym))
420                   rc=-1;
421               }
422             else if((val=string_to_digest_algo (tok)))
423               {
424                 if(set_one_pref(val,2,tok,hash,&nhash))
425                   rc=-1;
426               }
427             else if((val=string_to_compress_algo(tok))>-1)
428               {
429                 if(set_one_pref(val,3,tok,zip,&nzip))
430                   rc=-1;
431               }
432             else if (ascii_strcasecmp(tok,"mdc")==0)
433               mdc=1;
434             else if (ascii_strcasecmp(tok,"no-mdc")==0)
435               mdc=0;
436             else if (ascii_strcasecmp(tok,"ks-modify")==0)
437               modify=1;
438             else if (ascii_strcasecmp(tok,"no-ks-modify")==0)
439               modify=0;
440             else
441               {
442                 log_info (_("invalid item '%s' in preference string\n"),tok);
443                 rc=-1;
444               }
445           }
446
447         xfree(prefstring);
448       }
449
450     if(!rc)
451       {
452         if(personal)
453           {
454             if(personal==PREFTYPE_SYM)
455               {
456                 xfree(opt.personal_cipher_prefs);
457
458                 if(nsym==0)
459                   opt.personal_cipher_prefs=NULL;
460                 else
461                   {
462                     int i;
463
464                     opt.personal_cipher_prefs=
465                       xmalloc(sizeof(prefitem_t *)*(nsym+1));
466
467                     for (i=0; i<nsym; i++)
468                       {
469                         opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
470                         opt.personal_cipher_prefs[i].value = sym[i];
471                       }
472
473                     opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
474                     opt.personal_cipher_prefs[i].value = 0;
475                   }
476               }
477             else if(personal==PREFTYPE_HASH)
478               {
479                 xfree(opt.personal_digest_prefs);
480
481                 if(nhash==0)
482                   opt.personal_digest_prefs=NULL;
483                 else
484                   {
485                     int i;
486
487                     opt.personal_digest_prefs=
488                       xmalloc(sizeof(prefitem_t *)*(nhash+1));
489
490                     for (i=0; i<nhash; i++)
491                       {
492                         opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
493                         opt.personal_digest_prefs[i].value = hash[i];
494                       }
495
496                     opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
497                     opt.personal_digest_prefs[i].value = 0;
498                   }
499               }
500             else if(personal==PREFTYPE_ZIP)
501               {
502                 xfree(opt.personal_compress_prefs);
503
504                 if(nzip==0)
505                   opt.personal_compress_prefs=NULL;
506                 else
507                   {
508                     int i;
509
510                     opt.personal_compress_prefs=
511                       xmalloc(sizeof(prefitem_t *)*(nzip+1));
512
513                     for (i=0; i<nzip; i++)
514                       {
515                         opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
516                         opt.personal_compress_prefs[i].value = zip[i];
517                       }
518
519                     opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
520                     opt.personal_compress_prefs[i].value = 0;
521                   }
522               }
523           }
524         else
525           {
526             memcpy (sym_prefs,  sym,  (nsym_prefs=nsym));
527             memcpy (hash_prefs, hash, (nhash_prefs=nhash));
528             memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
529             mdc_available = mdc;
530             ks_modify = modify;
531             prefs_initialized = 1;
532           }
533       }
534
535     return rc;
536 }
537
538 /* Return a fake user ID containing the preferences.  Caller must
539    free. */
540 PKT_user_id *
541 keygen_get_std_prefs(void)
542 {
543   int i,j=0;
544   PKT_user_id *uid=xmalloc_clear(sizeof(PKT_user_id));
545
546   if(!prefs_initialized)
547     keygen_set_std_prefs(NULL,0);
548
549   uid->ref=1;
550
551   uid->prefs=xmalloc((sizeof(prefitem_t *)*
552                       (nsym_prefs+nhash_prefs+nzip_prefs+1)));
553
554   for(i=0;i<nsym_prefs;i++,j++)
555     {
556       uid->prefs[j].type=PREFTYPE_SYM;
557       uid->prefs[j].value=sym_prefs[i];
558     }
559
560   for(i=0;i<nhash_prefs;i++,j++)
561     {
562       uid->prefs[j].type=PREFTYPE_HASH;
563       uid->prefs[j].value=hash_prefs[i];
564     }
565
566   for(i=0;i<nzip_prefs;i++,j++)
567     {
568       uid->prefs[j].type=PREFTYPE_ZIP;
569       uid->prefs[j].value=zip_prefs[i];
570     }
571
572   uid->prefs[j].type=PREFTYPE_NONE;
573   uid->prefs[j].value=0;
574
575   uid->flags.mdc=mdc_available;
576   uid->flags.ks_modify=ks_modify;
577
578   return uid;
579 }
580
581 static void
582 add_feature_mdc (PKT_signature *sig,int enabled)
583 {
584     const byte *s;
585     size_t n;
586     int i;
587     char *buf;
588
589     s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n );
590     /* Already set or cleared */
591     if (s && n &&
592         ((enabled && (s[0] & 0x01)) || (!enabled && !(s[0] & 0x01))))
593       return;
594
595     if (!s || !n) { /* create a new one */
596         n = 1;
597         buf = xmalloc_clear (n);
598     }
599     else {
600         buf = xmalloc (n);
601         memcpy (buf, s, n);
602     }
603
604     if(enabled)
605       buf[0] |= 0x01; /* MDC feature */
606     else
607       buf[0] &= ~0x01;
608
609     /* Are there any bits set? */
610     for(i=0;i<n;i++)
611       if(buf[i]!=0)
612         break;
613
614     if(i==n)
615       delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
616     else
617       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
618
619     xfree (buf);
620 }
621
622 static void
623 add_keyserver_modify (PKT_signature *sig,int enabled)
624 {
625   const byte *s;
626   size_t n;
627   int i;
628   char *buf;
629
630   /* The keyserver modify flag is a negative flag (i.e. no-modify) */
631   enabled=!enabled;
632
633   s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n );
634   /* Already set or cleared */
635   if (s && n &&
636       ((enabled && (s[0] & 0x80)) || (!enabled && !(s[0] & 0x80))))
637     return;
638
639   if (!s || !n) { /* create a new one */
640     n = 1;
641     buf = xmalloc_clear (n);
642   }
643   else {
644     buf = xmalloc (n);
645     memcpy (buf, s, n);
646   }
647
648   if(enabled)
649     buf[0] |= 0x80; /* no-modify flag */
650   else
651     buf[0] &= ~0x80;
652
653   /* Are there any bits set? */
654   for(i=0;i<n;i++)
655     if(buf[i]!=0)
656       break;
657
658   if(i==n)
659     delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
660   else
661     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
662
663   xfree (buf);
664 }
665
666
667 int
668 keygen_upd_std_prefs (PKT_signature *sig, void *opaque)
669 {
670   (void)opaque;
671
672   if (!prefs_initialized)
673     keygen_set_std_prefs (NULL, 0);
674
675   if (nsym_prefs)
676     build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
677   else
678     {
679       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
680       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
681     }
682
683   if (nhash_prefs)
684     build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
685   else
686     {
687       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
688       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
689     }
690
691   if (nzip_prefs)
692     build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
693   else
694     {
695       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
696       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
697     }
698
699   /* Make sure that the MDC feature flag is set if needed.  */
700   add_feature_mdc (sig,mdc_available);
701   add_keyserver_modify (sig,ks_modify);
702   keygen_add_keyserver_url(sig,NULL);
703
704   return 0;
705 }
706
707
708 /****************
709  * Add preference to the self signature packet.
710  * This is only called for packets with version > 3.
711  */
712 int
713 keygen_add_std_prefs (PKT_signature *sig, void *opaque)
714 {
715   PKT_public_key *pk = opaque;
716
717   do_add_key_flags (sig, pk->pubkey_usage);
718   keygen_add_key_expire (sig, opaque );
719   keygen_upd_std_prefs (sig, opaque);
720   keygen_add_keyserver_url (sig,NULL);
721
722   return 0;
723 }
724
725 int
726 keygen_add_keyserver_url(PKT_signature *sig, void *opaque)
727 {
728   const char *url=opaque;
729
730   if(!url)
731     url=opt.def_keyserver_url;
732
733   if(url)
734     build_sig_subpkt(sig,SIGSUBPKT_PREF_KS,url,strlen(url));
735   else
736     delete_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS);
737
738   return 0;
739 }
740
741 int
742 keygen_add_notations(PKT_signature *sig,void *opaque)
743 {
744   struct notation *notation;
745
746   /* We always start clean */
747   delete_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION);
748   delete_sig_subpkt(sig->unhashed,SIGSUBPKT_NOTATION);
749   sig->flags.notation=0;
750
751   for(notation=opaque;notation;notation=notation->next)
752     if(!notation->flags.ignore)
753       {
754         unsigned char *buf;
755         unsigned int n1,n2;
756
757         n1=strlen(notation->name);
758         if(notation->altvalue)
759           n2=strlen(notation->altvalue);
760         else if(notation->bdat)
761           n2=notation->blen;
762         else
763           n2=strlen(notation->value);
764
765         buf = xmalloc( 8 + n1 + n2 );
766
767         /* human readable or not */
768         buf[0] = notation->bdat?0:0x80;
769         buf[1] = buf[2] = buf[3] = 0;
770         buf[4] = n1 >> 8;
771         buf[5] = n1;
772         buf[6] = n2 >> 8;
773         buf[7] = n2;
774         memcpy(buf+8, notation->name, n1 );
775         if(notation->altvalue)
776           memcpy(buf+8+n1, notation->altvalue, n2 );
777         else if(notation->bdat)
778           memcpy(buf+8+n1, notation->bdat, n2 );
779         else
780           memcpy(buf+8+n1, notation->value, n2 );
781         build_sig_subpkt( sig, SIGSUBPKT_NOTATION |
782                           (notation->flags.critical?SIGSUBPKT_FLAG_CRITICAL:0),
783                           buf, 8+n1+n2 );
784         xfree(buf);
785       }
786
787   return 0;
788 }
789
790 int
791 keygen_add_revkey (PKT_signature *sig, void *opaque)
792 {
793   struct revocation_key *revkey = opaque;
794   byte buf[2+MAX_FINGERPRINT_LEN];
795
796   buf[0] = revkey->class;
797   buf[1] = revkey->algid;
798   memcpy (&buf[2], revkey->fpr, MAX_FINGERPRINT_LEN);
799
800   build_sig_subpkt (sig, SIGSUBPKT_REV_KEY, buf, 2+MAX_FINGERPRINT_LEN);
801
802   /* All sigs with revocation keys set are nonrevocable.  */
803   sig->flags.revocable = 0;
804   buf[0] = 0;
805   build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
806
807   parse_revkeys (sig);
808
809   return 0;
810 }
811
812
813
814 /* Create a back-signature.  If TIMESTAMP is not NULL, use it for the
815    signature creation time.  */
816 gpg_error_t
817 make_backsig (PKT_signature *sig, PKT_public_key *pk,
818               PKT_public_key *sub_pk, PKT_public_key *sub_psk,
819               u32 timestamp, const char *cache_nonce)
820 {
821   gpg_error_t err;
822   PKT_signature *backsig;
823
824   cache_public_key (sub_pk);
825
826   err = make_keysig_packet (&backsig, pk, NULL, sub_pk, sub_psk, 0x19,
827                             0, 0, timestamp, 0, NULL, NULL, cache_nonce);
828   if (err)
829     log_error ("make_keysig_packet failed for backsig: %s\n", g10_errstr(err));
830   else
831     {
832       /* Get it into a binary packed form. */
833       IOBUF backsig_out = iobuf_temp();
834       PACKET backsig_pkt;
835
836       init_packet (&backsig_pkt);
837       backsig_pkt.pkttype = PKT_SIGNATURE;
838       backsig_pkt.pkt.signature = backsig;
839       err = build_packet (backsig_out, &backsig_pkt);
840       free_packet (&backsig_pkt);
841       if (err)
842         log_error ("build_packet failed for backsig: %s\n", g10_errstr(err));
843       else
844         {
845           size_t pktlen = 0;
846           byte *buf = iobuf_get_temp_buffer (backsig_out);
847
848           /* Remove the packet header. */
849           if(buf[0]&0x40)
850             {
851               if (buf[1] < 192)
852                 {
853                   pktlen = buf[1];
854                   buf += 2;
855                 }
856               else if(buf[1] < 224)
857                 {
858                   pktlen = (buf[1]-192)*256;
859                   pktlen += buf[2]+192;
860                   buf += 3;
861                 }
862               else if (buf[1] == 255)
863                 {
864                   pktlen  = buf[2] << 24;
865                   pktlen |= buf[3] << 16;
866                   pktlen |= buf[4] << 8;
867                   pktlen |= buf[5];
868                   buf += 6;
869                 }
870               else
871                 BUG ();
872             }
873           else
874             {
875               int mark = 1;
876
877               switch (buf[0]&3)
878                 {
879                 case 3:
880                   BUG ();
881                   break;
882
883                 case 2:
884                   pktlen  = buf[mark++] << 24;
885                   pktlen |= buf[mark++] << 16;
886
887                 case 1:
888                   pktlen |= buf[mark++] << 8;
889
890                 case 0:
891                   pktlen |= buf[mark++];
892                 }
893
894               buf += mark;
895             }
896
897           /* Now make the binary blob into a subpacket.  */
898           build_sig_subpkt (sig, SIGSUBPKT_SIGNATURE, buf, pktlen);
899
900           iobuf_close (backsig_out);
901         }
902     }
903
904   return err;
905 }
906
907
908 /* Write a direct key signature to the first key in ROOT using the key
909    PSK.  REVKEY is describes the direct key signature and TIMESTAMP is
910    the timestamp to set on the signature.  */
911 static gpg_error_t
912 write_direct_sig (KBNODE root, PKT_public_key *psk,
913                   struct revocation_key *revkey, u32 timestamp,
914                   const char *cache_nonce)
915 {
916   gpg_error_t err;
917   PACKET *pkt;
918   PKT_signature *sig;
919   KBNODE node;
920   PKT_public_key *pk;
921
922   if (opt.verbose)
923     log_info (_("writing direct signature\n"));
924
925   /* Get the pk packet from the pub_tree. */
926   node = find_kbnode (root, PKT_PUBLIC_KEY);
927   if (!node)
928     BUG ();
929   pk = node->pkt->pkt.public_key;
930
931   /* We have to cache the key, so that the verification of the
932      signature creation is able to retrieve the public key.  */
933   cache_public_key (pk);
934
935   /* Make the signature.  */
936   err = make_keysig_packet (&sig, pk, NULL,NULL, psk, 0x1F,
937                             0, 0, timestamp, 0,
938                             keygen_add_revkey, revkey, cache_nonce);
939   if (err)
940     {
941       log_error ("make_keysig_packet failed: %s\n", g10_errstr (err) );
942       return err;
943     }
944
945   pkt = xmalloc_clear (sizeof *pkt);
946   pkt->pkttype = PKT_SIGNATURE;
947   pkt->pkt.signature = sig;
948   add_kbnode (root, new_kbnode (pkt));
949   return err;
950 }
951
952
953
954 /* Write a self-signature to the first user id in ROOT using the key
955    PSK.  USE and TIMESTAMP give the extra data we need for the
956    signature.  */
957 static gpg_error_t
958 write_selfsigs (KBNODE root, PKT_public_key *psk,
959                 unsigned int use, u32 timestamp, const char *cache_nonce)
960 {
961   gpg_error_t err;
962   PACKET *pkt;
963   PKT_signature *sig;
964   PKT_user_id *uid;
965   KBNODE node;
966   PKT_public_key *pk;
967
968   if (opt.verbose)
969     log_info (_("writing self signature\n"));
970
971   /* Get the uid packet from the list. */
972   node = find_kbnode (root, PKT_USER_ID);
973   if (!node)
974     BUG(); /* No user id packet in tree.  */
975   uid = node->pkt->pkt.user_id;
976
977   /* Get the pk packet from the pub_tree. */
978   node = find_kbnode (root, PKT_PUBLIC_KEY);
979   if (!node)
980     BUG();
981   pk = node->pkt->pkt.public_key;
982
983   /* The usage has not yet been set - do it now. */
984   pk->pubkey_usage = use;
985
986   /* We have to cache the key, so that the verification of the
987      signature creation is able to retrieve the public key.  */
988   cache_public_key (pk);
989
990   /* Make the signature.  */
991   err = make_keysig_packet (&sig, pk, uid, NULL, psk, 0x13,
992                             0, 0, timestamp, 0,
993                             keygen_add_std_prefs, pk, cache_nonce);
994   if (err)
995     {
996       log_error ("make_keysig_packet failed: %s\n", g10_errstr (err));
997       return err;
998     }
999
1000   pkt = xmalloc_clear (sizeof *pkt);
1001   pkt->pkttype = PKT_SIGNATURE;
1002   pkt->pkt.signature = sig;
1003   add_kbnode (root, new_kbnode (pkt));
1004
1005   return err;
1006 }
1007
1008
1009 /* Write the key binding signature.  If TIMESTAMP is not NULL use the
1010    signature creation time.  PRI_PSK is the key use for signing.
1011    SUB_PSK is a key used to create a back-signature; that one is only
1012    used if USE has the PUBKEY_USAGE_SIG capability.  */
1013 static int
1014 write_keybinding (KBNODE root, PKT_public_key *pri_psk, PKT_public_key *sub_psk,
1015                   unsigned int use, u32 timestamp, const char *cache_nonce)
1016 {
1017   gpg_error_t err;
1018   PACKET *pkt;
1019   PKT_signature *sig;
1020   KBNODE node;
1021   PKT_public_key *pri_pk, *sub_pk;
1022   struct opaque_data_usage_and_pk oduap;
1023
1024   if (opt.verbose)
1025     log_info(_("writing key binding signature\n"));
1026
1027   /* Get the primary pk packet from the tree.  */
1028   node = find_kbnode (root, PKT_PUBLIC_KEY);
1029   if (!node)
1030     BUG();
1031   pri_pk = node->pkt->pkt.public_key;
1032
1033   /* We have to cache the key, so that the verification of the
1034    * signature creation is able to retrieve the public key.  */
1035   cache_public_key (pri_pk);
1036
1037   /* Find the last subkey. */
1038   sub_pk = NULL;
1039   for (node = root; node; node = node->next )
1040     {
1041       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1042         sub_pk = node->pkt->pkt.public_key;
1043     }
1044   if (!sub_pk)
1045     BUG();
1046
1047   /* Make the signature.  */
1048   oduap.usage = use;
1049   oduap.pk = sub_pk;
1050   err = make_keysig_packet (&sig, pri_pk, NULL, sub_pk, pri_psk, 0x18,
1051                             0, 0, timestamp, 0,
1052                             keygen_add_key_flags_and_expire, &oduap,
1053                             cache_nonce);
1054   if (err)
1055     {
1056       log_error ("make_keysig_packet failed: %s\n", g10_errstr (err));
1057       return err;
1058     }
1059
1060   /* Make a backsig.  */
1061   if (use & PUBKEY_USAGE_SIG)
1062     {
1063       err = make_backsig (sig, pri_pk, sub_pk, sub_psk, timestamp, cache_nonce);
1064       if (err)
1065         return err;
1066     }
1067
1068   pkt = xmalloc_clear ( sizeof *pkt );
1069   pkt->pkttype = PKT_SIGNATURE;
1070   pkt->pkt.signature = sig;
1071   add_kbnode (root, new_kbnode (pkt) );
1072   return err;
1073 }
1074
1075
1076 static gpg_error_t
1077 ecckey_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp, int algo)
1078 {
1079   gpg_error_t err;
1080   gcry_sexp_t list, l2;
1081   char *curve;
1082   int i;
1083   const char *oidstr;
1084   unsigned int nbits;
1085
1086   array[0] = NULL;
1087   array[1] = NULL;
1088   array[2] = NULL;
1089
1090   list = gcry_sexp_find_token (sexp, "public-key", 0);
1091   if (!list)
1092     return gpg_error (GPG_ERR_INV_OBJ);
1093   l2 = gcry_sexp_cadr (list);
1094   gcry_sexp_release (list);
1095   list = l2;
1096   if (!list)
1097     return gpg_error (GPG_ERR_NO_OBJ);
1098
1099   l2 = gcry_sexp_find_token (list, "curve", 0);
1100   if (!l2)
1101     {
1102       err = gpg_error (GPG_ERR_NO_OBJ);
1103       goto leave;
1104     }
1105   curve = gcry_sexp_nth_string (l2, 1);
1106   if (!curve)
1107     {
1108       err = gpg_error (GPG_ERR_NO_OBJ);
1109       goto leave;
1110     }
1111   gcry_sexp_release (l2);
1112   oidstr = openpgp_curve_to_oid (curve, &nbits);
1113   if (!oidstr)
1114     {
1115       /* That can't happen because we used one of the curves
1116          gpg_curve_to_oid knows about.  */
1117       err = gpg_error (GPG_ERR_INV_OBJ);
1118       goto leave;
1119     }
1120   err = openpgp_oid_from_str (oidstr, &array[0]);
1121   if (err)
1122     goto leave;
1123
1124   l2 = gcry_sexp_find_token (list, "q", 0);
1125   if (!l2)
1126     {
1127       err = gpg_error (GPG_ERR_NO_OBJ);
1128       goto leave;
1129     }
1130   array[1] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1131   gcry_sexp_release (l2);
1132   if (!array[1])
1133     {
1134       err = gpg_error (GPG_ERR_INV_OBJ);
1135       goto leave;
1136     }
1137   gcry_sexp_release (list);
1138
1139   if (algo == PUBKEY_ALGO_ECDH)
1140     {
1141       array[2] = pk_ecdh_default_params (nbits);
1142       if (!array[2])
1143         {
1144           err = gpg_error_from_syserror ();
1145           goto leave;
1146         }
1147     }
1148
1149  leave:
1150   if (err)
1151     {
1152       for (i=0; i < 3; i++)
1153         {
1154           gcry_mpi_release (array[i]);
1155           array[i] = NULL;
1156         }
1157     }
1158   return err;
1159 }
1160
1161
1162 /* Extract key parameters from SEXP and store them in ARRAY.  ELEMS is
1163    a string where each character denotes a parameter name.  TOPNAME is
1164    the name of the top element above the elements.  */
1165 static int
1166 key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
1167                const char *topname, const char *elems)
1168 {
1169   gcry_sexp_t list, l2;
1170   const char *s;
1171   int i, idx;
1172   int rc = 0;
1173
1174   list = gcry_sexp_find_token (sexp, topname, 0);
1175   if (!list)
1176     return gpg_error (GPG_ERR_INV_OBJ);
1177   l2 = gcry_sexp_cadr (list);
1178   gcry_sexp_release (list);
1179   list = l2;
1180   if (!list)
1181     return gpg_error (GPG_ERR_NO_OBJ);
1182
1183   for (idx=0,s=elems; *s; s++, idx++)
1184     {
1185       l2 = gcry_sexp_find_token (list, s, 1);
1186       if (!l2)
1187         {
1188           rc = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
1189           goto leave;
1190         }
1191       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1192       gcry_sexp_release (l2);
1193       if (!array[idx])
1194         {
1195           rc = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
1196           goto leave;
1197         }
1198     }
1199   gcry_sexp_release (list);
1200
1201  leave:
1202   if (rc)
1203     {
1204       for (i=0; i<idx; i++)
1205         {
1206           gcry_mpi_release (array[i]);
1207           array[i] = NULL;
1208         }
1209       gcry_sexp_release (list);
1210     }
1211   return rc;
1212 }
1213
1214
1215 /* Create a keyblock using the given KEYGRIP.  ALGO is the OpenPGP
1216    algorithm of that keygrip.  */
1217 static int
1218 do_create_from_keygrip (ctrl_t ctrl, int algo, const char *hexkeygrip,
1219                         kbnode_t pub_root, u32 timestamp, u32 expireval,
1220                         int is_subkey)
1221 {
1222   int err;
1223   PACKET *pkt;
1224   PKT_public_key *pk;
1225   gcry_sexp_t s_key;
1226   const char *algoelem;
1227
1228   if (hexkeygrip[0] == '&')
1229     hexkeygrip++;
1230
1231   switch (algo)
1232     {
1233     case PUBKEY_ALGO_RSA:       algoelem = "ne"; break;
1234     case PUBKEY_ALGO_DSA:       algoelem = "pqgy"; break;
1235     case PUBKEY_ALGO_ELGAMAL_E: algoelem = "pgy"; break;
1236     case PUBKEY_ALGO_ECDH:
1237     case PUBKEY_ALGO_ECDSA:     algoelem = ""; break;
1238     case PUBKEY_ALGO_EDDSA:     algoelem = ""; break;
1239     default: return gpg_error (GPG_ERR_INTERNAL);
1240     }
1241
1242
1243   /* Ask the agent for the public key matching HEXKEYGRIP.  */
1244   {
1245     unsigned char *public;
1246
1247     err = agent_readkey (ctrl, 0, hexkeygrip, &public);
1248     if (err)
1249       return err;
1250     err = gcry_sexp_sscan (&s_key, NULL,
1251                            public, gcry_sexp_canon_len (public, 0, NULL, NULL));
1252     xfree (public);
1253     if (err)
1254       return err;
1255   }
1256
1257   /* Build a public key packet.  */
1258   pk = xtrycalloc (1, sizeof *pk);
1259   if (!pk)
1260     {
1261       err = gpg_error_from_syserror ();
1262       gcry_sexp_release (s_key);
1263       return err;
1264     }
1265
1266   pk->timestamp = timestamp;
1267   pk->version = 4;
1268   if (expireval)
1269     pk->expiredate = pk->timestamp + expireval;
1270   pk->pubkey_algo = algo;
1271
1272   if (algo == PUBKEY_ALGO_ECDSA
1273       || algo == PUBKEY_ALGO_EDDSA
1274       || algo == PUBKEY_ALGO_ECDH )
1275     err = ecckey_from_sexp (pk->pkey, s_key, algo);
1276   else
1277     err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
1278   if (err)
1279     {
1280       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
1281       gcry_sexp_release (s_key);
1282       free_public_key (pk);
1283       return err;
1284     }
1285   gcry_sexp_release (s_key);
1286
1287   pkt = xtrycalloc (1, sizeof *pkt);
1288   if (!pkt)
1289     {
1290       err = gpg_error_from_syserror ();
1291       free_public_key (pk);
1292       return err;
1293     }
1294
1295   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1296   pkt->pkt.public_key = pk;
1297   add_kbnode (pub_root, new_kbnode (pkt));
1298
1299   return 0;
1300 }
1301
1302
1303 /* Common code for the key generation fucntion gen_xxx.  */
1304 static int
1305 common_gen (const char *keyparms, int algo, const char *algoelem,
1306             kbnode_t pub_root, u32 timestamp, u32 expireval, int is_subkey,
1307             int keygen_flags, char **cache_nonce_addr)
1308 {
1309   int err;
1310   PACKET *pkt;
1311   PKT_public_key *pk;
1312   gcry_sexp_t s_key;
1313
1314   err = agent_genkey (NULL, cache_nonce_addr, keyparms,
1315                       !!(keygen_flags & KEYGEN_FLAG_NO_PROTECTION), &s_key);
1316   if (err)
1317     {
1318       log_error ("agent_genkey failed: %s\n", gpg_strerror (err) );
1319       return err;
1320     }
1321
1322   pk = xtrycalloc (1, sizeof *pk);
1323   if (!pk)
1324     {
1325       err = gpg_error_from_syserror ();
1326       gcry_sexp_release (s_key);
1327       return err;
1328     }
1329
1330   pk->timestamp = timestamp;
1331   pk->version = 4;
1332   if (expireval)
1333     pk->expiredate = pk->timestamp + expireval;
1334   pk->pubkey_algo = algo;
1335
1336   if (algo == PUBKEY_ALGO_ECDSA
1337       || algo == PUBKEY_ALGO_EDDSA
1338       || algo == PUBKEY_ALGO_ECDH )
1339     err = ecckey_from_sexp (pk->pkey, s_key, algo);
1340   else
1341     err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
1342   if (err)
1343     {
1344       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
1345       gcry_sexp_release (s_key);
1346       free_public_key (pk);
1347       return err;
1348     }
1349   gcry_sexp_release (s_key);
1350
1351   pkt = xtrycalloc (1, sizeof *pkt);
1352   if (!pkt)
1353     {
1354       err = gpg_error_from_syserror ();
1355       free_public_key (pk);
1356       return err;
1357     }
1358
1359   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1360   pkt->pkt.public_key = pk;
1361   add_kbnode (pub_root, new_kbnode (pkt));
1362
1363   return 0;
1364 }
1365
1366
1367 /*
1368  * Generate an Elgamal key.
1369  */
1370 static int
1371 gen_elg (int algo, unsigned int nbits, KBNODE pub_root,
1372          u32 timestamp, u32 expireval, int is_subkey,
1373          int keygen_flags, char **cache_nonce_addr)
1374 {
1375   int err;
1376   char *keyparms;
1377   char nbitsstr[35];
1378
1379   assert (is_ELGAMAL (algo));
1380
1381   if (nbits < 512)
1382     {
1383       nbits = 2048;
1384       log_info (_("keysize invalid; using %u bits\n"), nbits );
1385     }
1386
1387   if ((nbits % 32))
1388     {
1389       nbits = ((nbits + 31) / 32) * 32;
1390       log_info (_("keysize rounded up to %u bits\n"), nbits );
1391     }
1392
1393   /* Note that we use transient-key only if no-protection has also
1394      been enabled.  */
1395   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1396   keyparms = xtryasprintf ("(genkey(%s(nbits %zu:%s)%s))",
1397                            algo == GCRY_PK_ELG_E ? "openpgp-elg" :
1398                            algo == GCRY_PK_ELG   ? "elg" : "x-oops" ,
1399                            strlen (nbitsstr), nbitsstr,
1400                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1401                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1402                            "(transient-key)" : "" );
1403   if (!keyparms)
1404     err = gpg_error_from_syserror ();
1405   else
1406     {
1407       err = common_gen (keyparms, algo, "pgy",
1408                         pub_root, timestamp, expireval, is_subkey,
1409                         keygen_flags, cache_nonce_addr);
1410       xfree (keyparms);
1411     }
1412
1413   return err;
1414 }
1415
1416
1417 /*
1418  * Generate an DSA key
1419  */
1420 static gpg_error_t
1421 gen_dsa (unsigned int nbits, KBNODE pub_root,
1422          u32 timestamp, u32 expireval, int is_subkey,
1423          int keygen_flags, char **cache_nonce_addr)
1424 {
1425   int err;
1426   unsigned int qbits;
1427   char *keyparms;
1428   char nbitsstr[35];
1429   char qbitsstr[35];
1430
1431   if ( nbits < 512)
1432     {
1433       nbits = 2048;
1434       log_info(_("keysize invalid; using %u bits\n"), nbits );
1435     }
1436   else if ( nbits > 3072 )
1437     {
1438       nbits = 3072;
1439       log_info(_("keysize invalid; using %u bits\n"), nbits );
1440     }
1441
1442   if( (nbits % 64) )
1443     {
1444       nbits = ((nbits + 63) / 64) * 64;
1445       log_info(_("keysize rounded up to %u bits\n"), nbits );
1446     }
1447
1448   /* To comply with FIPS rules we round up to the next value unless in
1449      expert mode.  */
1450   if (!opt.expert && nbits > 1024 && (nbits % 1024))
1451     {
1452       nbits = ((nbits + 1023) / 1024) * 1024;
1453       log_info(_("keysize rounded up to %u bits\n"), nbits );
1454     }
1455
1456   /*
1457     Figure out a q size based on the key size.  FIPS 180-3 says:
1458
1459     L = 1024, N = 160
1460     L = 2048, N = 224
1461     L = 2048, N = 256
1462     L = 3072, N = 256
1463
1464     2048/256 is an odd pair since there is also a 2048/224 and
1465     3072/256.  Matching sizes is not a very exact science.
1466
1467     We'll do 256 qbits for nbits over 2047, 224 for nbits over 1024
1468     but less than 2048, and 160 for 1024 (DSA1).
1469   */
1470
1471   if (nbits > 2047)
1472     qbits = 256;
1473   else if ( nbits > 1024)
1474     qbits = 224;
1475   else
1476     qbits = 160;
1477
1478   if (qbits != 160 )
1479     log_info (_("WARNING: some OpenPGP programs can't"
1480                 " handle a DSA key with this digest size\n"));
1481
1482   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1483   snprintf (qbitsstr, sizeof qbitsstr, "%u", qbits);
1484   keyparms = xtryasprintf ("(genkey(dsa(nbits %zu:%s)(qbits %zu:%s)%s))",
1485                            strlen (nbitsstr), nbitsstr,
1486                            strlen (qbitsstr), qbitsstr,
1487                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1488                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1489                            "(transient-key)" : "" );
1490   if (!keyparms)
1491     err = gpg_error_from_syserror ();
1492   else
1493     {
1494       err = common_gen (keyparms, PUBKEY_ALGO_DSA, "pqgy",
1495                         pub_root, timestamp, expireval, is_subkey,
1496                         keygen_flags, cache_nonce_addr);
1497       xfree (keyparms);
1498     }
1499
1500   return err;
1501 }
1502
1503
1504
1505 /*
1506  * Generate an ECC key
1507  */
1508 static gpg_error_t
1509 gen_ecc (int algo, const char *curve, kbnode_t pub_root,
1510          u32 timestamp, u32 expireval, int is_subkey,
1511          int keygen_flags, char **cache_nonce_addr)
1512 {
1513   gpg_error_t err;
1514   char *keyparms;
1515
1516   assert (algo == PUBKEY_ALGO_ECDSA
1517           || algo == PUBKEY_ALGO_EDDSA
1518           || algo == PUBKEY_ALGO_ECDH);
1519
1520   if (!curve || !*curve)
1521     return gpg_error (GPG_ERR_UNKNOWN_CURVE);
1522
1523   keyparms = xtryasprintf ("(genkey(ecc(curve %zu:%s)(flags nocomp%s%s)))",
1524                            strlen (curve), curve,
1525                            (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1526                              && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1527                             " transient-key" : ""),
1528                            (!strcmp (curve, "Ed25519")? " eddsa":""));
1529   if (!keyparms)
1530     err = gpg_error_from_syserror ();
1531   else
1532     {
1533       err = common_gen (keyparms, algo, "",
1534                         pub_root, timestamp, expireval, is_subkey,
1535                         keygen_flags, cache_nonce_addr);
1536       xfree (keyparms);
1537     }
1538
1539   return err;
1540 }
1541
1542
1543 /*
1544  * Generate an RSA key.
1545  */
1546 static int
1547 gen_rsa (int algo, unsigned int nbits, KBNODE pub_root,
1548          u32 timestamp, u32 expireval, int is_subkey,
1549          int keygen_flags, char **cache_nonce_addr)
1550 {
1551   int err;
1552   char *keyparms;
1553   char nbitsstr[35];
1554
1555   assert (is_RSA(algo));
1556
1557   if (!nbits)
1558     nbits = DEFAULT_STD_KEYSIZE;
1559
1560   if (nbits < 1024)
1561     {
1562       nbits = 2048;
1563       log_info (_("keysize invalid; using %u bits\n"), nbits );
1564     }
1565
1566   if ((nbits % 32))
1567     {
1568       nbits = ((nbits + 31) / 32) * 32;
1569       log_info (_("keysize rounded up to %u bits\n"), nbits );
1570     }
1571
1572   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1573   keyparms = xtryasprintf ("(genkey(rsa(nbits %zu:%s)%s))",
1574                            strlen (nbitsstr), nbitsstr,
1575                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1576                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1577                            "(transient-key)" : "" );
1578   if (!keyparms)
1579     err = gpg_error_from_syserror ();
1580   else
1581     {
1582       err = common_gen (keyparms, algo, "ne",
1583                         pub_root, timestamp, expireval, is_subkey,
1584                         keygen_flags, cache_nonce_addr);
1585       xfree (keyparms);
1586     }
1587
1588   return err;
1589 }
1590
1591
1592 /****************
1593  * check valid days:
1594  * return 0 on error or the multiplier
1595  */
1596 static int
1597 check_valid_days( const char *s )
1598 {
1599     if( !digitp(s) )
1600         return 0;
1601     for( s++; *s; s++)
1602         if( !digitp(s) )
1603             break;
1604     if( !*s )
1605         return 1;
1606     if( s[1] )
1607         return 0; /* e.g. "2323wc" */
1608     if( *s == 'd' || *s == 'D' )
1609         return 1;
1610     if( *s == 'w' || *s == 'W' )
1611         return 7;
1612     if( *s == 'm' || *s == 'M' )
1613         return 30;
1614     if( *s == 'y' || *s == 'Y' )
1615         return 365;
1616     return 0;
1617 }
1618
1619
1620 static void
1621 print_key_flags(int flags)
1622 {
1623   if(flags&PUBKEY_USAGE_SIG)
1624     tty_printf("%s ",_("Sign"));
1625
1626   if(flags&PUBKEY_USAGE_CERT)
1627     tty_printf("%s ",_("Certify"));
1628
1629   if(flags&PUBKEY_USAGE_ENC)
1630     tty_printf("%s ",_("Encrypt"));
1631
1632   if(flags&PUBKEY_USAGE_AUTH)
1633     tty_printf("%s ",_("Authenticate"));
1634 }
1635
1636
1637 /* Returns the key flags */
1638 static unsigned int
1639 ask_key_flags(int algo,int subkey)
1640 {
1641   /* TRANSLATORS: Please use only plain ASCII characters for the
1642      translation.  If this is not possible use single digits.  The
1643      string needs to 8 bytes long. Here is a description of the
1644      functions:
1645
1646        s = Toggle signing capability
1647        e = Toggle encryption capability
1648        a = Toggle authentication capability
1649        q = Finish
1650   */
1651   const char *togglers=_("SsEeAaQq");
1652   char *answer=NULL;
1653   unsigned int current=0;
1654   unsigned int possible=openpgp_pk_algo_usage(algo);
1655
1656   if ( strlen(togglers) != 8 )
1657     {
1658       tty_printf ("NOTE: Bad translation at %s:%d. "
1659                   "Please report.\n", __FILE__, __LINE__);
1660       togglers = "11223300";
1661     }
1662
1663   /* Only primary keys may certify. */
1664   if(subkey)
1665     possible&=~PUBKEY_USAGE_CERT;
1666
1667   /* Preload the current set with the possible set, minus
1668      authentication, since nobody really uses auth yet. */
1669   current=possible&~PUBKEY_USAGE_AUTH;
1670
1671   for(;;)
1672     {
1673       tty_printf("\n");
1674       tty_printf(_("Possible actions for a %s key: "),
1675                  openpgp_pk_algo_name (algo));
1676       print_key_flags(possible);
1677       tty_printf("\n");
1678       tty_printf(_("Current allowed actions: "));
1679       print_key_flags(current);
1680       tty_printf("\n\n");
1681
1682       if(possible&PUBKEY_USAGE_SIG)
1683         tty_printf(_("   (%c) Toggle the sign capability\n"),
1684                    togglers[0]);
1685       if(possible&PUBKEY_USAGE_ENC)
1686         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
1687                    togglers[2]);
1688       if(possible&PUBKEY_USAGE_AUTH)
1689         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
1690                    togglers[4]);
1691
1692       tty_printf(_("   (%c) Finished\n"),togglers[6]);
1693       tty_printf("\n");
1694
1695       xfree(answer);
1696       answer = cpr_get("keygen.flags",_("Your selection? "));
1697       cpr_kill_prompt();
1698
1699       if(strlen(answer)>1)
1700         tty_printf(_("Invalid selection.\n"));
1701       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1702         break;
1703       else if((*answer==togglers[0] || *answer==togglers[1])
1704               && possible&PUBKEY_USAGE_SIG)
1705         {
1706           if(current&PUBKEY_USAGE_SIG)
1707             current&=~PUBKEY_USAGE_SIG;
1708           else
1709             current|=PUBKEY_USAGE_SIG;
1710         }
1711       else if((*answer==togglers[2] || *answer==togglers[3])
1712               && possible&PUBKEY_USAGE_ENC)
1713         {
1714           if(current&PUBKEY_USAGE_ENC)
1715             current&=~PUBKEY_USAGE_ENC;
1716           else
1717             current|=PUBKEY_USAGE_ENC;
1718         }
1719       else if((*answer==togglers[4] || *answer==togglers[5])
1720               && possible&PUBKEY_USAGE_AUTH)
1721         {
1722           if(current&PUBKEY_USAGE_AUTH)
1723             current&=~PUBKEY_USAGE_AUTH;
1724           else
1725             current|=PUBKEY_USAGE_AUTH;
1726         }
1727       else
1728         tty_printf(_("Invalid selection.\n"));
1729     }
1730
1731   xfree(answer);
1732
1733   return current;
1734 }
1735
1736
1737 /* Check whether we have a key for the key with HEXGRIP.  Returns 0 if
1738    there is no such key or the OpenPGP algo number for the key.  */
1739 static int
1740 check_keygrip (ctrl_t ctrl, const char *hexgrip)
1741 {
1742   gpg_error_t err;
1743   unsigned char *public;
1744   size_t publiclen;
1745   const char *algostr;
1746
1747   if (hexgrip[0] == '&')
1748     hexgrip++;
1749
1750   err = agent_readkey (ctrl, 0, hexgrip, &public);
1751   if (err)
1752     return 0;
1753   publiclen = gcry_sexp_canon_len (public, 0, NULL, NULL);
1754
1755   get_pk_algo_from_canon_sexp (public, publiclen, &algostr);
1756   xfree (public);
1757
1758   /* FIXME: Mapping of ECC algorithms is probably not correct. */
1759   if (!algostr)
1760     return 0;
1761   else if (!strcmp (algostr, "rsa"))
1762     return PUBKEY_ALGO_RSA;
1763   else if (!strcmp (algostr, "dsa"))
1764     return PUBKEY_ALGO_DSA;
1765   else if (!strcmp (algostr, "elg"))
1766     return PUBKEY_ALGO_ELGAMAL_E;
1767   else if (!strcmp (algostr, "ecc"))
1768     return PUBKEY_ALGO_ECDH;
1769   else if (!strcmp (algostr, "ecdsa"))
1770     return PUBKEY_ALGO_ECDSA;
1771   else if (!strcmp (algostr, "eddsa"))
1772     return PUBKEY_ALGO_EDDSA;
1773   else
1774     return 0;
1775 }
1776
1777
1778
1779 /* Ask for an algorithm.  The function returns the algorithm id to
1780  * create. If ADDMODE is false the function won't show an option to
1781  * create the primary and subkey combined and won't set R_USAGE
1782  * either.  If a combined algorithm has been selected, the subkey
1783  * algorithm is stored at R_SUBKEY_ALGO.  If R_KEYGRIP is given, the
1784  * user has the choice to enter the keygrip of an existing key.  That
1785  * keygrip is then stored at this address.  The caller needs to free
1786  * it. */
1787 static int
1788 ask_algo (ctrl_t ctrl, int addmode, int *r_subkey_algo, unsigned int *r_usage,
1789           char **r_keygrip)
1790 {
1791   char *keygrip = NULL;
1792   char *answer;
1793   int algo;
1794   int dummy_algo;
1795
1796   if (!r_subkey_algo)
1797     r_subkey_algo = &dummy_algo;
1798
1799   tty_printf (_("Please select what kind of key you want:\n"));
1800
1801 #if GPG_USE_RSA
1802   if (!addmode)
1803     tty_printf (_("   (%d) RSA and RSA (default)\n"), 1 );
1804 #endif
1805
1806   if (!addmode)
1807     tty_printf (_("   (%d) DSA and Elgamal\n"), 2 );
1808
1809   tty_printf (_("   (%d) DSA (sign only)\n"), 3 );
1810 #if GPG_USE_RSA
1811   tty_printf (_("   (%d) RSA (sign only)\n"), 4 );
1812 #endif
1813
1814   if (addmode)
1815     {
1816       tty_printf (_("   (%d) Elgamal (encrypt only)\n"), 5 );
1817 #if GPG_USE_RSA
1818       tty_printf (_("   (%d) RSA (encrypt only)\n"), 6 );
1819 #endif
1820     }
1821   if (opt.expert)
1822     {
1823       tty_printf (_("   (%d) DSA (set your own capabilities)\n"), 7 );
1824 #if GPG_USE_RSA
1825       tty_printf (_("   (%d) RSA (set your own capabilities)\n"), 8 );
1826 #endif
1827     }
1828
1829 #if GPG_USE_ECDSA || GPG_USE_ECDH || GPG_USE_EDDSA
1830   if (opt.expert && !addmode)
1831     tty_printf (_("   (%d) ECC\n"), 9 );
1832   if (opt.expert)
1833     tty_printf (_("  (%d) ECC (sign only)\n"), 10 );
1834   if (opt.expert)
1835     tty_printf (_("  (%d) ECC (set your own capabilities)\n"), 11 );
1836   if (opt.expert && addmode)
1837     tty_printf (_("  (%d) ECC (encrypt only)\n"), 12 );
1838 #endif
1839
1840   if (opt.expert && r_keygrip)
1841     tty_printf (_("  (%d) Existing key\n"), 13 );
1842
1843   for (;;)
1844     {
1845       *r_usage = 0;
1846       *r_subkey_algo = 0;
1847       answer = cpr_get ("keygen.algo", _("Your selection? "));
1848       cpr_kill_prompt ();
1849       algo = *answer? atoi (answer) : 1;
1850       xfree(answer);
1851       answer = NULL;
1852       if (algo == 1 && !addmode)
1853         {
1854           algo = PUBKEY_ALGO_RSA;
1855           *r_subkey_algo = PUBKEY_ALGO_RSA;
1856           break;
1857         }
1858       else if (algo == 2 && !addmode)
1859         {
1860           algo = PUBKEY_ALGO_DSA;
1861           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
1862           break;
1863         }
1864       else if (algo == 3)
1865         {
1866           algo = PUBKEY_ALGO_DSA;
1867           *r_usage = PUBKEY_USAGE_SIG;
1868           break;
1869         }
1870       else if (algo == 4)
1871         {
1872           algo = PUBKEY_ALGO_RSA;
1873           *r_usage = PUBKEY_USAGE_SIG;
1874           break;
1875         }
1876       else if (algo == 5 && addmode)
1877         {
1878           algo = PUBKEY_ALGO_ELGAMAL_E;
1879           *r_usage = PUBKEY_USAGE_ENC;
1880           break;
1881         }
1882       else if (algo == 6 && addmode)
1883         {
1884           algo = PUBKEY_ALGO_RSA;
1885           *r_usage = PUBKEY_USAGE_ENC;
1886           break;
1887         }
1888       else if (algo == 7 && opt.expert)
1889         {
1890           algo = PUBKEY_ALGO_DSA;
1891           *r_usage = ask_key_flags (algo, addmode);
1892           break;
1893         }
1894       else if (algo == 8 && opt.expert)
1895         {
1896           algo = PUBKEY_ALGO_RSA;
1897           *r_usage = ask_key_flags (algo, addmode);
1898           break;
1899         }
1900       else if (algo == 9 && opt.expert && !addmode)
1901         {
1902           algo = PUBKEY_ALGO_ECDSA;
1903           *r_subkey_algo = PUBKEY_ALGO_ECDH;
1904           break;
1905         }
1906       else if (algo == 10 && opt.expert)
1907         {
1908           algo = PUBKEY_ALGO_ECDSA;
1909           *r_usage = PUBKEY_USAGE_SIG;
1910           break;
1911         }
1912       else if (algo == 11 && opt.expert)
1913         {
1914           algo = PUBKEY_ALGO_ECDSA;
1915           *r_usage = ask_key_flags (algo, addmode);
1916           break;
1917         }
1918       else if (algo == 12 && opt.expert && addmode)
1919         {
1920           algo = PUBKEY_ALGO_ECDH;
1921           *r_usage = PUBKEY_USAGE_ENC;
1922           break;
1923         }
1924       else if (algo == 13 && opt.expert && r_keygrip)
1925         {
1926           for (;;)
1927             {
1928               xfree (answer);
1929               answer = tty_get (_("Enter the keygrip: "));
1930               tty_kill_prompt ();
1931               trim_spaces (answer);
1932               if (!*answer)
1933                 {
1934                   xfree (answer);
1935                   answer = NULL;
1936                   continue;
1937                 }
1938
1939               if (strlen (answer) != 40 &&
1940                        !(answer[0] == '&' && strlen (answer+1) == 40))
1941                 tty_printf
1942                   (_("Not a valid keygrip (expecting 40 hex digits)\n"));
1943               else if (!(algo = check_keygrip (ctrl, answer)) )
1944                 tty_printf (_("No key with this keygrip\n"));
1945               else
1946                 break; /* Okay.  */
1947             }
1948           xfree (keygrip);
1949           keygrip = answer;
1950           answer = NULL;
1951           *r_usage = ask_key_flags (algo, addmode);
1952           break;
1953         }
1954       else
1955         tty_printf (_("Invalid selection.\n"));
1956     }
1957
1958   if (r_keygrip)
1959     *r_keygrip = keygrip;
1960   return algo;
1961 }
1962
1963
1964 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
1965    is not 0, the function asks for the size of the encryption
1966    subkey. */
1967 static unsigned
1968 ask_keysize (int algo, unsigned int primary_keysize)
1969 {
1970   unsigned int nbits, min, def = DEFAULT_STD_KEYSIZE, max=4096;
1971   int for_subkey = !!primary_keysize;
1972   int autocomp = 0;
1973
1974   if(opt.expert)
1975     min=512;
1976   else
1977     min=1024;
1978
1979   if (primary_keysize && !opt.expert)
1980     {
1981       /* Deduce the subkey size from the primary key size.  */
1982       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
1983         nbits = 3072; /* For performance reasons we don't support more
1984                          than 3072 bit DSA.  However we won't see this
1985                          case anyway because DSA can't be used as an
1986                          encryption subkey ;-). */
1987       else
1988         nbits = primary_keysize;
1989       autocomp = 1;
1990       goto leave;
1991     }
1992
1993   switch(algo)
1994     {
1995     case PUBKEY_ALGO_DSA:
1996       def=2048;
1997       max=3072;
1998       break;
1999
2000     case PUBKEY_ALGO_ECDSA:
2001     case PUBKEY_ALGO_ECDH:
2002       min=256;
2003       def=256;
2004       max=521;
2005       break;
2006
2007     case PUBKEY_ALGO_EDDSA:
2008       min=255;
2009       def=255;
2010       max=441;
2011       break;
2012
2013     case PUBKEY_ALGO_RSA:
2014       min=1024;
2015       break;
2016     }
2017
2018   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
2019              openpgp_pk_algo_name (algo), min, max);
2020
2021   for (;;)
2022     {
2023       char *prompt, *answer;
2024
2025       if (for_subkey)
2026         prompt = xasprintf (_("What keysize do you want "
2027                               "for the subkey? (%u) "), def);
2028       else
2029         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
2030       answer = cpr_get ("keygen.size", prompt);
2031       cpr_kill_prompt ();
2032       nbits = *answer? atoi (answer): def;
2033       xfree(prompt);
2034       xfree(answer);
2035
2036       if(nbits<min || nbits>max)
2037         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
2038                    openpgp_pk_algo_name (algo), min, max);
2039       else
2040         break;
2041     }
2042
2043   tty_printf (_("Requested keysize is %u bits\n"), nbits);
2044
2045  leave:
2046   if (algo == PUBKEY_ALGO_DSA && (nbits % 64))
2047     {
2048       nbits = ((nbits + 63) / 64) * 64;
2049       if (!autocomp)
2050         tty_printf (_("rounded up to %u bits\n"), nbits);
2051     }
2052   else if (algo == PUBKEY_ALGO_EDDSA)
2053     {
2054       if (nbits != 255 && nbits != 441)
2055         {
2056           if (nbits < 256)
2057             nbits = 255;
2058           else
2059             nbits = 441;
2060           if (!autocomp)
2061             tty_printf (_("rounded to %u bits\n"), nbits);
2062         }
2063     }
2064   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
2065     {
2066       if (nbits != 256 && nbits != 384 && nbits != 521)
2067         {
2068           if (nbits < 256)
2069             nbits = 256;
2070           else if (nbits < 384)
2071             nbits = 384;
2072           else
2073             nbits = 521;
2074           if (!autocomp)
2075             tty_printf (_("rounded to %u bits\n"), nbits);
2076         }
2077     }
2078   else if ((nbits % 32))
2079     {
2080       nbits = ((nbits + 31) / 32) * 32;
2081       if (!autocomp)
2082         tty_printf (_("rounded up to %u bits\n"), nbits );
2083     }
2084
2085   return nbits;
2086 }
2087
2088
2089 /* Ask for the curve.  ALGO is the selected algorithm which this
2090    function may adjust.  Returns a malloced string with the name of
2091    the curve.  */
2092 static char *
2093 ask_curve (int *algo)
2094 {
2095   struct {
2096     const char *name;
2097     int available;
2098     int expert_only;
2099     int fix_curve;
2100     const char *pretty_name;
2101   } curves[] = {
2102 #if GPG_USE_EDDSA
2103     { "Curve25519",      0, 0, 1, "Curve 25519" },
2104 #endif
2105 #if GPG_USE_ECDSA || GPG_USE_ECDH
2106     { "NIST P-256",      0, 1, 0, },
2107     { "NIST P-384",      0, 0, 0, },
2108     { "NIST P-521",      0, 1, 0, },
2109     { "brainpoolP256r1", 0, 1, 0, "Brainpool P-256" },
2110     { "brainpoolP384r1", 0, 1, 0, "Brainpool P-384" },
2111     { "brainpoolP512r1", 0, 1, 0, "Brainpool P-512" },
2112     { "secp256k1",       0, 1, 0  },
2113 #endif
2114   };
2115   int idx;
2116   char *answer;
2117   char *result = NULL;
2118   gcry_sexp_t keyparms;
2119
2120   tty_printf (_("Please select which elliptic curve you want:\n"));
2121
2122   keyparms = NULL;
2123   for (idx=0; idx < DIM(curves); idx++)
2124     {
2125       int rc;
2126
2127       curves[idx].available = 0;
2128       if (!opt.expert && curves[idx].expert_only)
2129         continue;
2130
2131       /* FIXME: The strcmp below is a temporary hack during
2132          development.  It shall be removed as soon as we have proper
2133          Curve25519 support in Libgcrypt.  */
2134       gcry_sexp_release (keyparms);
2135       rc = gcry_sexp_build (&keyparms, NULL,
2136                             "(public-key(ecc(curve %s)))",
2137                             (!strcmp (curves[idx].name, "Curve25519")
2138                              ? "Ed25519" : curves[idx].name));
2139       if (rc)
2140         continue;
2141       if (!gcry_pk_get_curve (keyparms, 0, NULL))
2142         continue;
2143
2144       curves[idx].available = 1;
2145       tty_printf ("   (%d) %s\n", idx + 1,
2146                   curves[idx].pretty_name?
2147                   curves[idx].pretty_name:curves[idx].name);
2148     }
2149   gcry_sexp_release (keyparms);
2150
2151
2152   for (;;)
2153     {
2154       answer = cpr_get ("keygen.curve", _("Your selection? "));
2155       cpr_kill_prompt ();
2156       idx = *answer? atoi (answer) : 1;
2157       if (*answer && !idx)
2158         {
2159           /* See whether the user entered the name of the curve.  */
2160           for (idx=0; idx < DIM(curves); idx++)
2161             {
2162               if (!opt.expert && curves[idx].expert_only)
2163                 continue;
2164               if (!stricmp (curves[idx].name, answer)
2165                   || (curves[idx].pretty_name
2166                       && !stricmp (curves[idx].pretty_name, answer)))
2167                 break;
2168             }
2169           if (idx == DIM(curves))
2170             idx = -1;
2171         }
2172       else
2173         idx--;
2174       xfree(answer);
2175       answer = NULL;
2176       if (idx < 0 || idx >= DIM (curves) || !curves[idx].available)
2177         tty_printf (_("Invalid selection.\n"));
2178       else
2179         {
2180           if (curves[idx].fix_curve)
2181             log_info ("WARNING: Curve25519 is an experimental algorithm and"
2182                       " not yet specified by OpenPGP.  The current"
2183                       " implementation may change with the next GnuPG release"
2184                       " and thus rendering the key unusable!\n");
2185
2186           /* If the user selected a signing algorithm and Curve25519
2187              we need to update the algo and and the curve name.  */
2188           if ((*algo == PUBKEY_ALGO_ECDSA || *algo == PUBKEY_ALGO_EDDSA)
2189               && curves[idx].fix_curve)
2190             {
2191               *algo = PUBKEY_ALGO_EDDSA;
2192               result = xstrdup ("Ed25519");
2193             }
2194           else
2195             result = xstrdup (curves[idx].name);
2196           break;
2197         }
2198     }
2199
2200   if (!result)
2201     result = xstrdup (curves[0].name);
2202
2203   return result;
2204 }
2205
2206
2207 /****************
2208  * Parse an expire string and return its value in seconds.
2209  * Returns (u32)-1 on error.
2210  * This isn't perfect since scan_isodatestr returns unix time, and
2211  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
2212  * Because of this, we only permit setting expirations up to 2106, but
2213  * OpenPGP could theoretically allow up to 2242.  I think we'll all
2214  * just cope for the next few years until we get a 64-bit time_t or
2215  * similar.
2216  */
2217 u32
2218 parse_expire_string( const char *string )
2219 {
2220   int mult;
2221   u32 seconds;
2222   u32 abs_date = 0;
2223   u32 curtime = make_timestamp ();
2224   time_t tt;
2225
2226   if (!*string)
2227     seconds = 0;
2228   else if (!strncmp (string, "seconds=", 8))
2229     seconds = atoi (string+8);
2230   else if ((abs_date = scan_isodatestr(string))
2231            && (abs_date+86400/2) > curtime)
2232     seconds = (abs_date+86400/2) - curtime;
2233   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
2234     seconds = (u32)tt - curtime;
2235   else if ((mult = check_valid_days (string)))
2236     seconds = atoi (string) * 86400L * mult;
2237   else
2238     seconds = (u32)(-1);
2239
2240   return seconds;
2241 }
2242
2243 /* Parsean Creation-Date string which is either "1986-04-26" or
2244    "19860426T042640".  Returns 0 on error. */
2245 static u32
2246 parse_creation_string (const char *string)
2247 {
2248   u32 seconds;
2249
2250   if (!*string)
2251     seconds = 0;
2252   else if ( !strncmp (string, "seconds=", 8) )
2253     seconds = atoi (string+8);
2254   else if ( !(seconds = scan_isodatestr (string)))
2255     {
2256       time_t tmp = isotime2epoch (string);
2257       seconds = (tmp == (time_t)(-1))? 0 : tmp;
2258     }
2259   return seconds;
2260 }
2261
2262
2263 /* object == 0 for a key, and 1 for a sig */
2264 u32
2265 ask_expire_interval(int object,const char *def_expire)
2266 {
2267     u32 interval;
2268     char *answer;
2269
2270     switch(object)
2271       {
2272       case 0:
2273         if(def_expire)
2274           BUG();
2275         tty_printf(_("Please specify how long the key should be valid.\n"
2276                      "         0 = key does not expire\n"
2277                      "      <n>  = key expires in n days\n"
2278                      "      <n>w = key expires in n weeks\n"
2279                      "      <n>m = key expires in n months\n"
2280                      "      <n>y = key expires in n years\n"));
2281         break;
2282
2283       case 1:
2284         if(!def_expire)
2285           BUG();
2286         tty_printf(_("Please specify how long the signature should be valid.\n"
2287                      "         0 = signature does not expire\n"
2288                      "      <n>  = signature expires in n days\n"
2289                      "      <n>w = signature expires in n weeks\n"
2290                      "      <n>m = signature expires in n months\n"
2291                      "      <n>y = signature expires in n years\n"));
2292         break;
2293
2294       default:
2295         BUG();
2296       }
2297
2298     /* Note: The elgamal subkey for DSA has no expiration date because
2299      * it must be signed with the DSA key and this one has the expiration
2300      * date */
2301
2302     answer = NULL;
2303     for(;;)
2304       {
2305         u32 curtime;
2306
2307         xfree(answer);
2308         if(object==0)
2309           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
2310         else
2311           {
2312             char *prompt;
2313
2314 #define PROMPTSTRING _("Signature is valid for? (%s) ")
2315             /* This will actually end up larger than necessary because
2316                of the 2 bytes for '%s' */
2317             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
2318             sprintf(prompt,PROMPTSTRING,def_expire);
2319 #undef PROMPTSTRING
2320
2321             answer = cpr_get("siggen.valid",prompt);
2322             xfree(prompt);
2323
2324             if(*answer=='\0')
2325               answer=xstrdup(def_expire);
2326           }
2327         cpr_kill_prompt();
2328         trim_spaces(answer);
2329         curtime = make_timestamp ();
2330         interval = parse_expire_string( answer );
2331         if( interval == (u32)-1 )
2332           {
2333             tty_printf(_("invalid value\n"));
2334             continue;
2335           }
2336
2337         if( !interval )
2338           {
2339             tty_printf((object==0)
2340                        ? _("Key does not expire at all\n")
2341                        : _("Signature does not expire at all\n"));
2342           }
2343         else
2344           {
2345             tty_printf(object==0
2346                        ? _("Key expires at %s\n")
2347                        : _("Signature expires at %s\n"),
2348                        asctimestamp((ulong)(curtime + interval) ) );
2349 #if SIZEOF_TIME_T <= 4 && !defined (HAVE_UNSIGNED_TIME_T)
2350             if ( (time_t)((ulong)(curtime+interval)) < 0 )
2351               tty_printf (_("Your system can't display dates beyond 2038.\n"
2352                             "However, it will be correctly handled up to"
2353                             " 2106.\n"));
2354             else
2355 #endif /*SIZEOF_TIME_T*/
2356               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
2357                 {
2358                   tty_printf (_("invalid value\n"));
2359                   continue;
2360                 }
2361           }
2362
2363         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
2364                                                    _("Is this correct? (y/N) ")) )
2365           break;
2366       }
2367
2368     xfree(answer);
2369     return interval;
2370 }
2371
2372 u32
2373 ask_expiredate()
2374 {
2375     u32 x = ask_expire_interval(0,NULL);
2376     return x? make_timestamp() + x : 0;
2377 }
2378
2379
2380
2381 static PKT_user_id *
2382 uid_from_string (const char *string)
2383 {
2384   size_t n;
2385   PKT_user_id *uid;
2386
2387   n = strlen (string);
2388   uid = xmalloc_clear (sizeof *uid + n);
2389   uid->len = n;
2390   strcpy (uid->name, string);
2391   uid->ref = 1;
2392   return uid;
2393 }
2394
2395
2396 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
2397    printed for use during a new key creation.  If KEYBLOCK is not NULL
2398    the function prevents the creation of an already existing user
2399    ID.  */
2400 static char *
2401 ask_user_id (int mode, KBNODE keyblock)
2402 {
2403     char *answer;
2404     char *aname, *acomment, *amail, *uid;
2405
2406     if ( !mode )
2407       {
2408         /* TRANSLATORS: This is the new string telling the user what
2409            gpg is now going to do (i.e. ask for the parts of the user
2410            ID).  Note that if you do not translate this string, a
2411            different string will be used used, which might still have
2412            a correct translation.  */
2413         const char *s1 =
2414           N_("\n"
2415              "GnuPG needs to construct a user ID to identify your key.\n"
2416              "\n");
2417         const char *s2 = _(s1);
2418
2419         if (!strcmp (s1, s2))
2420           {
2421             /* There is no translation for the string thus we to use
2422                the old info text.  gettext has no way to tell whether
2423                a translation is actually available, thus we need to
2424                to compare again. */
2425             /* TRANSLATORS: This string is in general not anymore used
2426                but you should keep your existing translation.  In case
2427                the new string is not translated this old string will
2428                be used. */
2429             const char *s3 = N_("\n"
2430 "You need a user ID to identify your key; "
2431                                         "the software constructs the user ID\n"
2432 "from the Real Name, Comment and Email Address in this form:\n"
2433 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
2434             const char *s4 = _(s3);
2435             if (strcmp (s3, s4))
2436               s2 = s3; /* A translation exists - use it. */
2437           }
2438         tty_printf ("%s", s2) ;
2439       }
2440     uid = aname = acomment = amail = NULL;
2441     for(;;) {
2442         char *p;
2443         int fail=0;
2444
2445         if( !aname ) {
2446             for(;;) {
2447                 xfree(aname);
2448                 aname = cpr_get("keygen.name",_("Real name: "));
2449                 trim_spaces(aname);
2450                 cpr_kill_prompt();
2451
2452                 if( opt.allow_freeform_uid )
2453                     break;
2454
2455                 if( strpbrk( aname, "<>" ) )
2456                     tty_printf(_("Invalid character in name\n"));
2457                 else if( digitp(aname) )
2458                     tty_printf(_("Name may not start with a digit\n"));
2459                 else if( strlen(aname) < 5 )
2460                     tty_printf(_("Name must be at least 5 characters long\n"));
2461                 else
2462                     break;
2463             }
2464         }
2465         if( !amail ) {
2466             for(;;) {
2467                 xfree(amail);
2468                 amail = cpr_get("keygen.email",_("Email address: "));
2469                 trim_spaces(amail);
2470                 cpr_kill_prompt();
2471                 if( !*amail || opt.allow_freeform_uid )
2472                     break;   /* no email address is okay */
2473                 else if ( !is_valid_mailbox (amail) )
2474                     tty_printf(_("Not a valid email address\n"));
2475                 else
2476                     break;
2477             }
2478         }
2479         if( !acomment ) {
2480             for(;;) {
2481                 xfree(acomment);
2482                 acomment = cpr_get("keygen.comment",_("Comment: "));
2483                 trim_spaces(acomment);
2484                 cpr_kill_prompt();
2485                 if( !*acomment )
2486                     break;   /* no comment is okay */
2487                 else if( strpbrk( acomment, "()" ) )
2488                     tty_printf(_("Invalid character in comment\n"));
2489                 else
2490                     break;
2491             }
2492         }
2493
2494
2495         xfree(uid);
2496         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
2497         p = stpcpy(p, aname );
2498         if( *acomment )
2499             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
2500         if( *amail )
2501             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
2502
2503         /* Append a warning if the RNG is switched into fake mode.  */
2504         if ( random_is_faked ()  )
2505           strcpy(p, " (insecure!)" );
2506
2507         /* print a note in case that UTF8 mapping has to be done */
2508         for(p=uid; *p; p++ ) {
2509             if( *p & 0x80 ) {
2510                 tty_printf(_("You are using the '%s' character set.\n"),
2511                            get_native_charset() );
2512                 break;
2513             }
2514         }
2515
2516         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2517
2518         if( !*amail && !opt.allow_freeform_uid
2519             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2520             fail = 1;
2521             tty_printf(_("Please don't put the email address "
2522                          "into the real name or the comment\n") );
2523         }
2524
2525         if (!fail && keyblock)
2526           {
2527             PKT_user_id *uidpkt = uid_from_string (uid);
2528             KBNODE node;
2529
2530             for (node=keyblock; node && !fail; node=node->next)
2531               if (!is_deleted_kbnode (node)
2532                   && node->pkt->pkttype == PKT_USER_ID
2533                   && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2534                 fail = 1;
2535             if (fail)
2536               tty_printf (_("Such a user ID already exists on this key!\n"));
2537             free_user_id (uidpkt);
2538           }
2539
2540         for(;;) {
2541             /* TRANSLATORS: These are the allowed answers in
2542                lower and uppercase.  Below you will find the matching
2543                string which should be translated accordingly and the
2544                letter changed to match the one in the answer string.
2545
2546                  n = Change name
2547                  c = Change comment
2548                  e = Change email
2549                  o = Okay (ready, continue)
2550                  q = Quit
2551              */
2552             const char *ansstr = _("NnCcEeOoQq");
2553
2554             if( strlen(ansstr) != 10 )
2555                 BUG();
2556             if( cpr_enabled() ) {
2557                 answer = xstrdup (ansstr + (fail?8:6));
2558                 answer[1] = 0;
2559             }
2560             else {
2561                 answer = cpr_get("keygen.userid.cmd", fail?
2562                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2563                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2564                 cpr_kill_prompt();
2565             }
2566             if( strlen(answer) > 1 )
2567                 ;
2568             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2569                 xfree(aname); aname = NULL;
2570                 break;
2571             }
2572             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2573                 xfree(acomment); acomment = NULL;
2574                 break;
2575             }
2576             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2577                 xfree(amail); amail = NULL;
2578                 break;
2579             }
2580             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2581                 if( fail ) {
2582                     tty_printf(_("Please correct the error first\n"));
2583                 }
2584                 else {
2585                     xfree(aname); aname = NULL;
2586                     xfree(acomment); acomment = NULL;
2587                     xfree(amail); amail = NULL;
2588                     break;
2589                 }
2590             }
2591             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2592                 xfree(aname); aname = NULL;
2593                 xfree(acomment); acomment = NULL;
2594                 xfree(amail); amail = NULL;
2595                 xfree(uid); uid = NULL;
2596                 break;
2597             }
2598             xfree(answer);
2599         }
2600         xfree(answer);
2601         if( !amail && !acomment && !amail )
2602             break;
2603         xfree(uid); uid = NULL;
2604     }
2605     if( uid ) {
2606         char *p = native_to_utf8( uid );
2607         xfree( uid );
2608         uid = p;
2609     }
2610     return uid;
2611 }
2612
2613
2614 /*  MODE  0 - standard
2615           1 - Ask for passphrase of the card backup key.  */
2616 static DEK *
2617 do_ask_passphrase (STRING2KEY **ret_s2k, int mode, int *r_canceled)
2618 {
2619     DEK *dek = NULL;
2620     STRING2KEY *s2k;
2621     const char *errtext = NULL;
2622     const char *custdesc = NULL;
2623
2624     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
2625
2626     if (mode == 1)
2627       custdesc = _("Please enter a passphrase to protect the off-card "
2628                    "backup of the new encryption key.");
2629
2630     s2k = xmalloc_secure( sizeof *s2k );
2631     for(;;) {
2632         s2k->mode = opt.s2k_mode;
2633         s2k->hash_algo = S2K_DIGEST_ALGO;
2634         dek = passphrase_to_dek_ext (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2635                                      errtext, custdesc, NULL, r_canceled);
2636         if (!dek && *r_canceled) {
2637             xfree(dek); dek = NULL;
2638             xfree(s2k); s2k = NULL;
2639             break;
2640         }
2641         else if( !dek ) {
2642             errtext = N_("passphrase not correctly repeated; try again");
2643             tty_printf(_("%s.\n"), _(errtext));
2644         }
2645         else if( !dek->keylen ) {
2646             xfree(dek); dek = NULL;
2647             xfree(s2k); s2k = NULL;
2648             tty_printf(_(
2649             "You don't want a passphrase - this is probably a *bad* idea!\n"
2650             "I will do it anyway.  You can change your passphrase at any time,\n"
2651             "using this program with the option \"--edit-key\".\n\n"));
2652             break;
2653         }
2654         else
2655             break; /* okay */
2656     }
2657     *ret_s2k = s2k;
2658     return dek;
2659 }
2660
2661
2662 /* Basic key generation.  Here we divert to the actual generation
2663    routines based on the requested algorithm.  */
2664 static int
2665 do_create (int algo, unsigned int nbits, const char *curve, KBNODE pub_root,
2666            u32 timestamp, u32 expiredate, int is_subkey,
2667            int keygen_flags, char **cache_nonce_addr)
2668 {
2669   gpg_error_t err;
2670
2671   /* Fixme: The entropy collecting message should be moved to a
2672      libgcrypt progress handler.  */
2673   if (!opt.batch)
2674     tty_printf (_(
2675 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2676 "some other action (type on the keyboard, move the mouse, utilize the\n"
2677 "disks) during the prime generation; this gives the random number\n"
2678 "generator a better chance to gain enough entropy.\n") );
2679
2680   if (algo == PUBKEY_ALGO_ELGAMAL_E)
2681     err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2682                    keygen_flags, cache_nonce_addr);
2683   else if (algo == PUBKEY_ALGO_DSA)
2684     err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
2685                    keygen_flags, cache_nonce_addr);
2686   else if (algo == PUBKEY_ALGO_ECDSA
2687            || algo == PUBKEY_ALGO_EDDSA
2688            || algo == PUBKEY_ALGO_ECDH)
2689     err = gen_ecc (algo, curve, pub_root, timestamp, expiredate, is_subkey,
2690                    keygen_flags, cache_nonce_addr);
2691   else if (algo == PUBKEY_ALGO_RSA)
2692     err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2693                    keygen_flags, cache_nonce_addr);
2694   else
2695     BUG();
2696
2697   return err;
2698 }
2699
2700
2701 /* Generate a new user id packet or return NULL if canceled.  If
2702    KEYBLOCK is not NULL the function prevents the creation of an
2703    already existing user ID.  */
2704 PKT_user_id *
2705 generate_user_id (KBNODE keyblock)
2706 {
2707   char *p;
2708
2709   p = ask_user_id (1, keyblock);
2710   if (!p)
2711     return NULL;  /* Canceled. */
2712   return uid_from_string (p);
2713 }
2714
2715
2716 /* Append R to the linked list PARA.  */
2717 static void
2718 append_to_parameter (struct para_data_s *para, struct para_data_s *r)
2719 {
2720   assert (para);
2721   while (para->next)
2722     para = para->next;
2723   para->next = r;
2724 }
2725
2726 /* Release the parameter list R.  */
2727 static void
2728 release_parameter_list (struct para_data_s *r)
2729 {
2730   struct para_data_s *r2;
2731
2732   for (; r ; r = r2)
2733     {
2734       r2 = r->next;
2735       if (r->key == pPASSPHRASE_DEK)
2736         xfree (r->u.dek);
2737       else if (r->key == pPASSPHRASE_S2K )
2738         xfree (r->u.s2k);
2739
2740       xfree (r);
2741     }
2742 }
2743
2744 static struct para_data_s *
2745 get_parameter( struct para_data_s *para, enum para_name key )
2746 {
2747     struct para_data_s *r;
2748
2749     for( r = para; r && r->key != key; r = r->next )
2750         ;
2751     return r;
2752 }
2753
2754 static const char *
2755 get_parameter_value( struct para_data_s *para, enum para_name key )
2756 {
2757     struct para_data_s *r = get_parameter( para, key );
2758     return (r && *r->u.value)? r->u.value : NULL;
2759 }
2760
2761 static int
2762 get_parameter_algo( struct para_data_s *para, enum para_name key,
2763                     int *r_default)
2764 {
2765   int i;
2766   struct para_data_s *r = get_parameter( para, key );
2767
2768   if (r_default)
2769     *r_default = 0;
2770
2771   if (!r)
2772     return -1;
2773
2774   if (!ascii_strcasecmp (r->u.value, "default"))
2775     {
2776       /* Note: If you change this default algo, remember to change it
2777          also in gpg.c:gpgconf_list.  */
2778       i = DEFAULT_STD_ALGO;
2779       if (r_default)
2780         *r_default = 1;
2781     }
2782   else if (digitp (r->u.value))
2783     i = atoi( r->u.value );
2784   else if (!strcmp (r->u.value, "ELG-E")
2785            || !strcmp (r->u.value, "ELG"))
2786     i = GCRY_PK_ELG_E;
2787   else
2788     i = map_pk_gcry_to_openpgp (gcry_pk_map_name (r->u.value));
2789
2790   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2791     i = 0; /* we don't want to allow generation of these algorithms */
2792   return i;
2793 }
2794
2795 /*
2796  * Parse the usage parameter and set the keyflags.  Returns -1 on
2797  * error, 0 for no usage given or 1 for usage available.
2798  */
2799 static int
2800 parse_parameter_usage (const char *fname,
2801                        struct para_data_s *para, enum para_name key)
2802 {
2803     struct para_data_s *r = get_parameter( para, key );
2804     char *p, *pn;
2805     unsigned int use;
2806
2807     if( !r )
2808         return 0; /* none (this is an optional parameter)*/
2809
2810     use = 0;
2811     pn = r->u.value;
2812     while ( (p = strsep (&pn, " \t,")) ) {
2813         if ( !*p)
2814             ;
2815         else if ( !ascii_strcasecmp (p, "sign") )
2816             use |= PUBKEY_USAGE_SIG;
2817         else if ( !ascii_strcasecmp (p, "encrypt") )
2818             use |= PUBKEY_USAGE_ENC;
2819         else if ( !ascii_strcasecmp (p, "auth") )
2820             use |= PUBKEY_USAGE_AUTH;
2821         else {
2822             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2823             return -1; /* error */
2824         }
2825     }
2826     r->u.usage = use;
2827     return 1;
2828 }
2829
2830 static int
2831 parse_revocation_key (const char *fname,
2832                       struct para_data_s *para, enum para_name key)
2833 {
2834   struct para_data_s *r = get_parameter( para, key );
2835   struct revocation_key revkey;
2836   char *pn;
2837   int i;
2838
2839   if( !r )
2840     return 0; /* none (this is an optional parameter) */
2841
2842   pn = r->u.value;
2843
2844   revkey.class=0x80;
2845   revkey.algid=atoi(pn);
2846   if(!revkey.algid)
2847     goto fail;
2848
2849   /* Skip to the fpr */
2850   while(*pn && *pn!=':')
2851     pn++;
2852
2853   if(*pn!=':')
2854     goto fail;
2855
2856   pn++;
2857
2858   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2859     {
2860       int c=hextobyte(pn);
2861       if(c==-1)
2862         goto fail;
2863
2864       revkey.fpr[i]=c;
2865     }
2866
2867   /* skip to the tag */
2868   while(*pn && *pn!='s' && *pn!='S')
2869     pn++;
2870
2871   if(ascii_strcasecmp(pn,"sensitive")==0)
2872     revkey.class|=0x40;
2873
2874   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2875
2876   return 0;
2877
2878   fail:
2879   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2880   return -1; /* error */
2881 }
2882
2883
2884 static u32
2885 get_parameter_u32( struct para_data_s *para, enum para_name key )
2886 {
2887   struct para_data_s *r = get_parameter( para, key );
2888
2889   if( !r )
2890     return 0;
2891   if( r->key == pKEYCREATIONDATE )
2892     return r->u.creation;
2893   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2894     return r->u.expire;
2895   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2896     return r->u.usage;
2897
2898   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2899 }
2900
2901 static unsigned int
2902 get_parameter_uint( struct para_data_s *para, enum para_name key )
2903 {
2904     return get_parameter_u32( para, key );
2905 }
2906
2907 static struct revocation_key *
2908 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2909 {
2910     struct para_data_s *r = get_parameter( para, key );
2911     return r? &r->u.revkey : NULL;
2912 }
2913
2914 static int
2915 proc_parameter_file( struct para_data_s *para, const char *fname,
2916                      struct output_control_s *outctrl, int card )
2917 {
2918   struct para_data_s *r;
2919   const char *s1, *s2, *s3;
2920   size_t n;
2921   char *p;
2922   int is_default = 0;
2923   int have_user_id = 0;
2924   int err, algo;
2925
2926   /* Check that we have all required parameters. */
2927   r = get_parameter( para, pKEYTYPE );
2928   if(r)
2929     {
2930       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
2931       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2932         {
2933           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2934           return -1;
2935         }
2936     }
2937   else
2938     {
2939       log_error ("%s: no Key-Type specified\n",fname);
2940       return -1;
2941     }
2942
2943   err = parse_parameter_usage (fname, para, pKEYUSAGE);
2944   if (!err)
2945     {
2946       /* Default to algo capabilities if key-usage is not provided and
2947          no default algorithm has been requested.  */
2948       r = xmalloc_clear(sizeof(*r));
2949       r->key = pKEYUSAGE;
2950       r->u.usage = (is_default
2951                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
2952                     : openpgp_pk_algo_usage(algo));
2953       append_to_parameter (para, r);
2954     }
2955   else if (err == -1)
2956     return -1;
2957   else
2958     {
2959       r = get_parameter (para, pKEYUSAGE);
2960       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2961         {
2962           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
2963                      fname, r->lnr, algo);
2964           return -1;
2965         }
2966     }
2967
2968   is_default = 0;
2969   r = get_parameter( para, pSUBKEYTYPE );
2970   if(r)
2971     {
2972       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
2973       if (openpgp_pk_test_algo (algo))
2974         {
2975           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2976           return -1;
2977         }
2978
2979       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2980       if (!err)
2981         {
2982           /* Default to algo capabilities if subkey-usage is not
2983              provided */
2984           r = xmalloc_clear (sizeof(*r));
2985           r->key = pSUBKEYUSAGE;
2986           r->u.usage = (is_default
2987                         ? PUBKEY_USAGE_ENC
2988                         : openpgp_pk_algo_usage (algo));
2989           append_to_parameter (para, r);
2990         }
2991       else if (err == -1)
2992         return -1;
2993       else
2994         {
2995           r = get_parameter (para, pSUBKEYUSAGE);
2996           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2997             {
2998               log_error ("%s:%d: specified Subkey-Usage not allowed"
2999                          " for algo %d\n", fname, r->lnr, algo);
3000               return -1;
3001             }
3002         }
3003     }
3004
3005
3006   if( get_parameter_value( para, pUSERID ) )
3007     have_user_id=1;
3008   else
3009     {
3010       /* create the formatted user ID */
3011       s1 = get_parameter_value( para, pNAMEREAL );
3012       s2 = get_parameter_value( para, pNAMECOMMENT );
3013       s3 = get_parameter_value( para, pNAMEEMAIL );
3014       if( s1 || s2 || s3 )
3015         {
3016           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
3017           r = xmalloc_clear( sizeof *r + n + 20 );
3018           r->key = pUSERID;
3019           p = r->u.value;
3020           if( s1 )
3021             p = stpcpy(p, s1 );
3022           if( s2 )
3023             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
3024           if( s3 )
3025             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
3026           append_to_parameter (para, r);
3027           have_user_id=1;
3028         }
3029     }
3030
3031   if(!have_user_id)
3032     {
3033       log_error("%s: no User-ID specified\n",fname);
3034       return -1;
3035     }
3036
3037   /* Set preferences, if any. */
3038   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
3039
3040   /* Set keyserver, if any. */
3041   s1=get_parameter_value( para, pKEYSERVER );
3042   if(s1)
3043     {
3044       struct keyserver_spec *spec;
3045
3046       spec=parse_keyserver_uri(s1,1,NULL,0);
3047       if(spec)
3048         {
3049           free_keyserver_spec(spec);
3050           opt.def_keyserver_url=s1;
3051         }
3052       else
3053         {
3054           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
3055           return -1;
3056         }
3057     }
3058
3059   /* Set revoker, if any. */
3060   if (parse_revocation_key (fname, para, pREVOKER))
3061     return -1;
3062
3063   /* Make DEK and S2K from the Passphrase. */
3064   if (outctrl->ask_passphrase)
3065     {
3066       /* %ask-passphrase is active - ignore pPASSPRASE and ask.  This
3067          feature is required so that GUIs are able to do a key
3068          creation but have gpg-agent ask for the passphrase.  */
3069       int canceled = 0;
3070       STRING2KEY *s2k;
3071       DEK *dek;
3072
3073       dek = do_ask_passphrase (&s2k, 0, &canceled);
3074       if (dek)
3075         {
3076           r = xmalloc_clear( sizeof *r );
3077           r->key = pPASSPHRASE_DEK;
3078           r->u.dek = dek;
3079           append_to_parameter (para, r);
3080           r = xmalloc_clear( sizeof *r );
3081           r->key = pPASSPHRASE_S2K;
3082           r->u.s2k = s2k;
3083           append_to_parameter (para, r);
3084         }
3085
3086       if (canceled)
3087         {
3088           log_error ("%s:%d: key generation canceled\n", fname, r->lnr );
3089           return -1;
3090         }
3091     }
3092   else
3093     {
3094       r = get_parameter( para, pPASSPHRASE );
3095       if ( r && *r->u.value )
3096         {
3097           /* We have a plain text passphrase - create a DEK from it.
3098            * It is a little bit ridiculous to keep it in secure memory
3099            * but because we do this always, why not here.  */
3100           STRING2KEY *s2k;
3101           DEK *dek;
3102
3103           s2k = xmalloc ( sizeof *s2k );
3104           s2k->mode = opt.s2k_mode;
3105           s2k->hash_algo = S2K_DIGEST_ALGO;
3106           set_next_passphrase ( r->u.value );
3107           dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3108                                    NULL, NULL);
3109           if (!dek)
3110             {
3111               log_error ("%s:%d: error post processing the passphrase\n",
3112                          fname, r->lnr );
3113               xfree (s2k);
3114               return -1;
3115             }
3116           set_next_passphrase (NULL);
3117           memset (r->u.value, 0, strlen(r->u.value));
3118
3119           r = xmalloc_clear (sizeof *r);
3120           r->key = pPASSPHRASE_S2K;
3121           r->u.s2k = s2k;
3122           append_to_parameter (para, r);
3123           r = xmalloc_clear (sizeof *r);
3124           r->key = pPASSPHRASE_DEK;
3125           r->u.dek = dek;
3126           append_to_parameter (para, r);
3127         }
3128     }
3129
3130   /* Make KEYCREATIONDATE from Creation-Date.  */
3131   r = get_parameter (para, pCREATIONDATE);
3132   if (r && *r->u.value)
3133     {
3134       u32 seconds;
3135
3136       seconds = parse_creation_string (r->u.value);
3137       if (!seconds)
3138         {
3139           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
3140           return -1;
3141         }
3142       r->u.creation = seconds;
3143       r->key = pKEYCREATIONDATE;  /* Change that entry. */
3144     }
3145
3146   /* Make KEYEXPIRE from Expire-Date.  */
3147   r = get_parameter( para, pEXPIREDATE );
3148   if( r && *r->u.value )
3149     {
3150       u32 seconds;
3151
3152       seconds = parse_expire_string( r->u.value );
3153       if( seconds == (u32)-1 )
3154         {
3155           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
3156           return -1;
3157         }
3158       r->u.expire = seconds;
3159       r->key = pKEYEXPIRE;  /* change hat entry */
3160       /* also set it for the subkey */
3161       r = xmalloc_clear( sizeof *r + 20 );
3162       r->key = pSUBKEYEXPIRE;
3163       r->u.expire = seconds;
3164       append_to_parameter (para, r);
3165     }
3166
3167   do_generate_keypair( para, outctrl, card );
3168   return 0;
3169 }
3170
3171
3172 /****************
3173  * Kludge to allow non interactive key generation controlled
3174  * by a parameter file.
3175  * Note, that string parameters are expected to be in UTF-8
3176  */
3177 static void
3178 read_parameter_file( const char *fname )
3179 {
3180     static struct { const char *name;
3181                     enum para_name key;
3182     } keywords[] = {
3183         { "Key-Type",       pKEYTYPE},
3184         { "Key-Length",     pKEYLENGTH },
3185         { "Key-Curve",      pKEYCURVE },
3186         { "Key-Usage",      pKEYUSAGE },
3187         { "Subkey-Type",    pSUBKEYTYPE },
3188         { "Subkey-Length",  pSUBKEYLENGTH },
3189         { "Subkey-Curve",   pSUBKEYCURVE },
3190         { "Subkey-Usage",   pSUBKEYUSAGE },
3191         { "Name-Real",      pNAMEREAL },
3192         { "Name-Email",     pNAMEEMAIL },
3193         { "Name-Comment",   pNAMECOMMENT },
3194         { "Expire-Date",    pEXPIREDATE },
3195         { "Creation-Date",  pCREATIONDATE },
3196         { "Passphrase",     pPASSPHRASE },
3197         { "Preferences",    pPREFERENCES },
3198         { "Revoker",        pREVOKER },
3199         { "Handle",         pHANDLE },
3200         { "Keyserver",      pKEYSERVER },
3201         { NULL, 0 }
3202     };
3203     IOBUF fp;
3204     byte *line;
3205     unsigned int maxlen, nline;
3206     char *p;
3207     int lnr;
3208     const char *err = NULL;
3209     struct para_data_s *para, *r;
3210     int i;
3211     struct output_control_s outctrl;
3212
3213     memset( &outctrl, 0, sizeof( outctrl ) );
3214     outctrl.pub.afx = new_armor_context ();
3215
3216     if( !fname || !*fname)
3217       fname = "-";
3218
3219     fp = iobuf_open (fname);
3220     if (fp && is_secured_file (iobuf_get_fd (fp)))
3221       {
3222         iobuf_close (fp);
3223         fp = NULL;
3224         gpg_err_set_errno (EPERM);
3225       }
3226     if (!fp) {
3227       log_error (_("can't open '%s': %s\n"), fname, strerror(errno) );
3228       return;
3229     }
3230     iobuf_ioctl (fp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
3231
3232     lnr = 0;
3233     err = NULL;
3234     para = NULL;
3235     maxlen = 1024;
3236     line = NULL;
3237     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
3238         char *keyword, *value;
3239
3240         lnr++;
3241         if( !maxlen ) {
3242             err = "line too long";
3243             break;
3244         }
3245         for( p = line; isspace(*(byte*)p); p++ )
3246             ;
3247         if( !*p || *p == '#' )
3248             continue;
3249         keyword = p;
3250         if( *keyword == '%' ) {
3251             for( ; !isspace(*(byte*)p); p++ )
3252                 ;
3253             if( *p )
3254                 *p++ = 0;
3255             for( ; isspace(*(byte*)p); p++ )
3256                 ;
3257             value = p;
3258             trim_trailing_ws( value, strlen(value) );
3259             if( !ascii_strcasecmp( keyword, "%echo" ) )
3260                 log_info("%s\n", value );
3261             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
3262                 outctrl.dryrun = 1;
3263             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
3264                 outctrl.ask_passphrase = 1;
3265             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
3266                 outctrl.ask_passphrase = 0;
3267             else if( !ascii_strcasecmp( keyword, "%no-protection" ) )
3268                 outctrl.keygen_flags |= KEYGEN_FLAG_NO_PROTECTION;
3269             else if( !ascii_strcasecmp( keyword, "%transient-key" ) )
3270                 outctrl.keygen_flags |= KEYGEN_FLAG_TRANSIENT_KEY;
3271             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
3272                 outctrl.lnr = lnr;
3273                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
3274                   print_status_key_not_created
3275                     (get_parameter_value (para, pHANDLE));
3276                 release_parameter_list( para );
3277                 para = NULL;
3278             }
3279             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
3280                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
3281                     ; /* still the same file - ignore it */
3282                 else {
3283                     xfree( outctrl.pub.newfname );
3284                     outctrl.pub.newfname = xstrdup( value );
3285                     outctrl.use_files = 1;
3286                 }
3287             }
3288             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
3289               /* Ignore this command.  */
3290             }
3291             else
3292                 log_info("skipping control '%s' (%s)\n", keyword, value );
3293
3294
3295             continue;
3296         }
3297
3298
3299         if( !(p = strchr( p, ':' )) || p == keyword ) {
3300             err = "missing colon";
3301             break;
3302         }
3303         if( *p )
3304             *p++ = 0;
3305         for( ; isspace(*(byte*)p); p++ )
3306             ;
3307         if( !*p ) {
3308             err = "missing argument";
3309             break;
3310         }
3311         value = p;
3312         trim_trailing_ws( value, strlen(value) );
3313
3314         for(i=0; keywords[i].name; i++ ) {
3315             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
3316                 break;
3317         }
3318         if( !keywords[i].name ) {
3319             err = "unknown keyword";
3320             break;
3321         }
3322         if( keywords[i].key != pKEYTYPE && !para ) {
3323             err = "parameter block does not start with \"Key-Type\"";
3324             break;
3325         }
3326
3327         if( keywords[i].key == pKEYTYPE && para ) {
3328             outctrl.lnr = lnr;
3329             if (proc_parameter_file( para, fname, &outctrl, 0 ))
3330               print_status_key_not_created
3331                 (get_parameter_value (para, pHANDLE));
3332             release_parameter_list( para );
3333             para = NULL;
3334         }
3335         else {
3336             for( r = para; r; r = r->next ) {
3337                 if( r->key == keywords[i].key )
3338                     break;
3339             }
3340             if( r ) {
3341                 err = "duplicate keyword";
3342                 break;
3343             }
3344         }
3345         r = xmalloc_clear( sizeof *r + strlen( value ) );
3346         r->lnr = lnr;
3347         r->key = keywords[i].key;
3348         strcpy( r->u.value, value );
3349         r->next = para;
3350         para = r;
3351     }
3352     if( err )
3353         log_error("%s:%d: %s\n", fname, lnr, err );
3354     else if( iobuf_error (fp) ) {
3355         log_error("%s:%d: read error\n", fname, lnr);
3356     }
3357     else if( para ) {
3358         outctrl.lnr = lnr;
3359         if (proc_parameter_file( para, fname, &outctrl, 0 ))
3360           print_status_key_not_created (get_parameter_value (para, pHANDLE));
3361     }
3362
3363     if( outctrl.use_files ) { /* close open streams */
3364         iobuf_close( outctrl.pub.stream );
3365
3366         /* Must invalidate that ugly cache to actually close it.  */
3367         if (outctrl.pub.fname)
3368           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3369                        0, (char*)outctrl.pub.fname);
3370
3371         xfree( outctrl.pub.fname );
3372         xfree( outctrl.pub.newfname );
3373     }
3374
3375     release_parameter_list( para );
3376     iobuf_close (fp);
3377     release_armor_context (outctrl.pub.afx);
3378 }
3379
3380
3381 /*
3382  * Generate a keypair (fname is only used in batch mode) If
3383  * CARD_SERIALNO is not NULL the function will create the keys on an
3384  * OpenPGP Card.  If CARD_BACKUP_KEY has been set and CARD_SERIALNO is
3385  * NOT NULL, the encryption key for the card is generated on the host,
3386  * imported to the card and a backup file created by gpg-agent.
3387  */
3388 void
3389 generate_keypair (ctrl_t ctrl, const char *fname, const char *card_serialno,
3390                   int card_backup_key)
3391 {
3392   unsigned int nbits;
3393   char *uid = NULL;
3394   int algo;
3395   unsigned int use;
3396   int both = 0;
3397   u32 expire;
3398   struct para_data_s *para = NULL;
3399   struct para_data_s *r;
3400   struct output_control_s outctrl;
3401
3402 #ifndef ENABLE_CARD_SUPPORT
3403   (void)card_backup_key;
3404 #endif
3405
3406   memset( &outctrl, 0, sizeof( outctrl ) );
3407
3408   if (opt.batch && card_serialno)
3409     {
3410       /* We don't yet support unattended key generation. */
3411       log_error (_("can't do this in batch mode\n"));
3412       return;
3413     }
3414
3415   if (opt.batch)
3416     {
3417       read_parameter_file( fname );
3418       return;
3419     }
3420
3421   if (card_serialno)
3422     {
3423 #ifdef ENABLE_CARD_SUPPORT
3424       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
3425       r->key = pSERIALNO;
3426       strcpy( r->u.value, card_serialno);
3427       r->next = para;
3428       para = r;
3429
3430       algo = PUBKEY_ALGO_RSA;
3431
3432       r = xcalloc (1, sizeof *r + 20 );
3433       r->key = pKEYTYPE;
3434       sprintf( r->u.value, "%d", algo );
3435       r->next = para;
3436       para = r;
3437       r = xcalloc (1, sizeof *r + 20 );
3438       r->key = pKEYUSAGE;
3439       strcpy (r->u.value, "sign");
3440       r->next = para;
3441       para = r;
3442
3443       r = xcalloc (1, sizeof *r + 20 );
3444       r->key = pSUBKEYTYPE;
3445       sprintf( r->u.value, "%d", algo );
3446       r->next = para;
3447       para = r;
3448       r = xcalloc (1, sizeof *r + 20 );
3449       r->key = pSUBKEYUSAGE;
3450       strcpy (r->u.value, "encrypt");
3451       r->next = para;
3452       para = r;
3453
3454       r = xcalloc (1, sizeof *r + 20 );
3455       r->key = pAUTHKEYTYPE;
3456       sprintf( r->u.value, "%d", algo );
3457       r->next = para;
3458       para = r;
3459
3460       if (card_backup_key)
3461         {
3462           r = xcalloc (1, sizeof *r + 1);
3463           r->key = pCARDBACKUPKEY;
3464           strcpy (r->u.value, "1");
3465           r->next = para;
3466           para = r;
3467         }
3468 #endif /*ENABLE_CARD_SUPPORT*/
3469     }
3470   else
3471     {
3472       int subkey_algo;
3473       char *curve = NULL;
3474
3475       /* Fixme: To support creating a primary key by keygrip we better
3476          also define the keyword for the parameter file.  Note that
3477          the subkey case will never be asserted if a keygrip has been
3478          given.  */
3479       algo = ask_algo (ctrl, 0, &subkey_algo, &use, NULL);
3480       if (subkey_algo)
3481         {
3482           /* Create primary and subkey at once.  */
3483           both = 1;
3484           if (algo == PUBKEY_ALGO_ECDSA
3485               || algo == PUBKEY_ALGO_EDDSA
3486               || algo == PUBKEY_ALGO_ECDH)
3487             {
3488               curve = ask_curve (&algo);
3489               r = xmalloc_clear( sizeof *r + 20 );
3490               r->key = pKEYTYPE;
3491               sprintf( r->u.value, "%d", algo);
3492               r->next = para;
3493               para = r;
3494               nbits = 0;
3495               r = xmalloc_clear (sizeof *r + strlen (curve));
3496               r->key = pKEYCURVE;
3497               strcpy (r->u.value, curve);
3498               r->next = para;
3499               para = r;
3500             }
3501           else
3502             {
3503               r = xmalloc_clear( sizeof *r + 20 );
3504               r->key = pKEYTYPE;
3505               sprintf( r->u.value, "%d", algo);
3506               r->next = para;
3507               para = r;
3508               nbits = ask_keysize (algo, 0);
3509               r = xmalloc_clear( sizeof *r + 20 );
3510               r->key = pKEYLENGTH;
3511               sprintf( r->u.value, "%u", nbits);
3512               r->next = para;
3513               para = r;
3514             }
3515           r = xmalloc_clear( sizeof *r + 20 );
3516           r->key = pKEYUSAGE;
3517           strcpy( r->u.value, "sign" );
3518           r->next = para;
3519           para = r;
3520
3521           r = xmalloc_clear( sizeof *r + 20 );
3522           r->key = pSUBKEYTYPE;
3523           sprintf( r->u.value, "%d", subkey_algo);
3524           r->next = para;
3525           para = r;
3526           r = xmalloc_clear( sizeof *r + 20 );
3527           r->key = pSUBKEYUSAGE;
3528           strcpy( r->u.value, "encrypt" );
3529           r->next = para;
3530           para = r;
3531
3532           if (algo == PUBKEY_ALGO_ECDSA
3533               || algo == PUBKEY_ALGO_EDDSA
3534               || algo == PUBKEY_ALGO_ECDH)
3535             {
3536               if (algo == PUBKEY_ALGO_EDDSA
3537                   && subkey_algo == PUBKEY_ALGO_ECDH)
3538                 {
3539                   /* Need to switch to a different curve for the
3540                      encryption key.  */
3541                   xfree (curve);
3542                   curve = xstrdup ("Curve25519");
3543                 }
3544               r = xmalloc_clear (sizeof *r + strlen (curve));
3545               r->key = pSUBKEYCURVE;
3546               strcpy (r->u.value, curve);
3547               r->next = para;
3548               para = r;
3549             }
3550         }
3551       else /* Create only a single key.  */
3552         {
3553           /* For ECC we need to ask for the curve before storing the
3554              algo becuase ask_curve may change the algo.  */
3555           if (algo == PUBKEY_ALGO_ECDSA
3556               || algo == PUBKEY_ALGO_EDDSA
3557               || algo == PUBKEY_ALGO_ECDH)
3558             {
3559               curve = ask_curve (&algo);
3560               nbits = 0;
3561               r = xmalloc_clear (sizeof *r + strlen (curve));
3562               r->key = pKEYCURVE;
3563               strcpy (r->u.value, curve);
3564               r->next = para;
3565               para = r;
3566             }
3567
3568           r = xmalloc_clear( sizeof *r + 20 );
3569           r->key = pKEYTYPE;
3570           sprintf( r->u.value, "%d", algo );
3571           r->next = para;
3572           para = r;
3573
3574           if (use)
3575             {
3576               r = xmalloc_clear( sizeof *r + 25 );
3577               r->key = pKEYUSAGE;
3578               sprintf( r->u.value, "%s%s%s",
3579                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
3580                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
3581                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
3582               r->next = para;
3583               para = r;
3584             }
3585           nbits = 0;
3586         }
3587
3588       if (algo == PUBKEY_ALGO_ECDSA
3589           || algo == PUBKEY_ALGO_EDDSA
3590           || algo == PUBKEY_ALGO_ECDH)
3591         {
3592           /* The curve has already been set.  */
3593         }
3594       else
3595         {
3596           nbits = ask_keysize (both? subkey_algo : algo, nbits);
3597           r = xmalloc_clear( sizeof *r + 20 );
3598           r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
3599           sprintf( r->u.value, "%u", nbits);
3600           r->next = para;
3601           para = r;
3602         }
3603
3604       xfree (curve);
3605     }
3606
3607   expire = ask_expire_interval(0,NULL);
3608   r = xmalloc_clear( sizeof *r + 20 );
3609   r->key = pKEYEXPIRE;
3610   r->u.expire = expire;
3611   r->next = para;
3612   para = r;
3613   r = xmalloc_clear( sizeof *r + 20 );
3614   r->key = pSUBKEYEXPIRE;
3615   r->u.expire = expire;
3616   r->next = para;
3617   para = r;
3618
3619   uid = ask_user_id (0, NULL);
3620   if( !uid )
3621     {
3622       log_error(_("Key generation canceled.\n"));
3623       release_parameter_list( para );
3624       return;
3625     }
3626   r = xmalloc_clear( sizeof *r + strlen(uid) );
3627   r->key = pUSERID;
3628   strcpy( r->u.value, uid );
3629   r->next = para;
3630   para = r;
3631
3632   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
3633   release_parameter_list( para );
3634 }
3635
3636
3637 #if 0 /* not required */
3638 /* Generate a raw key and return it as a secret key packet.  The
3639    function will ask for the passphrase and return a protected as well
3640    as an unprotected copy of a new secret key packet.  0 is returned
3641    on success and the caller must then free the returned values.  */
3642 static int
3643 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
3644                   PKT_secret_key **r_sk_unprotected,
3645                   PKT_secret_key **r_sk_protected)
3646 {
3647   int rc;
3648   DEK *dek = NULL;
3649   STRING2KEY *s2k = NULL;
3650   PKT_secret_key *sk = NULL;
3651   int i;
3652   size_t nskey, npkey;
3653   gcry_sexp_t s_parms, s_key;
3654   int canceled;