gpg: Allow new user ids with only the mail address.
[gnupg.git] / g10 / keygen.c
1 /* keygen.c - Generate a key pair
2  * Copyright (C) 1998-2007, 2009-2011  Free Software Foundation, Inc.
3  * Copyright (C) 2014, 2015  Werner Koch
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 #include "../common/shareddefs.h"
46 #include "host2net.h"
47 #include "mbox-util.h"
48
49
50 /* The default algorithms.  If you change them remember to change them
51    also in gpg.c:gpgconf_list.  You should also check that the value
52    is inside the bounds enforced by ask_keysize and gen_xxx.  */
53 #define DEFAULT_STD_ALGO       PUBKEY_ALGO_RSA
54 #define DEFAULT_STD_KEYSIZE    2048
55 #define DEFAULT_STD_CURVE      NULL
56 #define DEFAULT_STD_SUBALGO    PUBKEY_ALGO_RSA
57 #define DEFAULT_STD_SUBKEYSIZE 2048
58 #define DEFAULT_STD_SUBCURVE   NULL
59
60 /* Flag bits used during key generation.  */
61 #define KEYGEN_FLAG_NO_PROTECTION 1
62 #define KEYGEN_FLAG_TRANSIENT_KEY 2
63
64 /* Maximum number of supported algorithm preferences.  */
65 #define MAX_PREFS 30
66
67 enum para_name {
68   pKEYTYPE,
69   pKEYLENGTH,
70   pKEYCURVE,
71   pKEYUSAGE,
72   pSUBKEYTYPE,
73   pSUBKEYLENGTH,
74   pSUBKEYCURVE,
75   pSUBKEYUSAGE,
76   pAUTHKEYTYPE,
77   pNAMEREAL,
78   pNAMEEMAIL,
79   pNAMECOMMENT,
80   pPREFERENCES,
81   pREVOKER,
82   pUSERID,
83   pCREATIONDATE,
84   pKEYCREATIONDATE, /* Same in seconds since epoch.  */
85   pEXPIREDATE,
86   pKEYEXPIRE, /* in n seconds */
87   pSUBKEYEXPIRE, /* in n seconds */
88   pPASSPHRASE,
89   pSERIALNO,
90   pCARDBACKUPKEY,
91   pHANDLE,
92   pKEYSERVER
93 };
94
95 struct para_data_s {
96     struct para_data_s *next;
97     int lnr;
98     enum para_name key;
99     union {
100         u32 expire;
101         u32 creation;
102         unsigned int usage;
103         struct revocation_key revkey;
104         char value[1];
105     } u;
106 };
107
108 struct output_control_s
109 {
110   int lnr;
111   int dryrun;
112   unsigned int keygen_flags;
113   int use_files;
114   struct {
115     char  *fname;
116     char  *newfname;
117     IOBUF stream;
118     armor_filter_context_t *afx;
119   } pub;
120 };
121
122
123 struct opaque_data_usage_and_pk {
124     unsigned int usage;
125     PKT_public_key *pk;
126 };
127
128
129 static int prefs_initialized = 0;
130 static byte sym_prefs[MAX_PREFS];
131 static int nsym_prefs;
132 static byte hash_prefs[MAX_PREFS];
133 static int nhash_prefs;
134 static byte zip_prefs[MAX_PREFS];
135 static int nzip_prefs;
136 static int mdc_available,ks_modify;
137
138 static void do_generate_keypair (ctrl_t ctrl, struct para_data_s *para,
139                                  struct output_control_s *outctrl, int card );
140 static int write_keyblock (iobuf_t out, kbnode_t node);
141 static gpg_error_t gen_card_key (int algo, int keyno, int is_primary,
142                                  kbnode_t pub_root,
143                                  u32 *timestamp, u32 expireval);
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             strcat(dummy_string,"S2 "); /* 3DES */
341
342             /* The default hash algo order is:
343                  SHA-256, SHA-384, SHA-512, SHA-224, SHA-1.
344              */
345             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA256))
346               strcat (dummy_string, "H8 ");
347
348             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA384))
349               strcat (dummy_string, "H9 ");
350
351             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA512))
352               strcat (dummy_string, "H10 ");
353
354             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA224))
355               strcat (dummy_string, "H11 ");
356
357             strcat (dummy_string, "H2 "); /* SHA-1 */
358
359             if(!check_compress_algo(COMPRESS_ALGO_ZLIB))
360               {
361                 strcat(dummy_string,"Z2 ");
362                 any_compress = 1;
363               }
364
365             if(!check_compress_algo(COMPRESS_ALGO_BZIP2))
366               {
367                 strcat(dummy_string,"Z3 ");
368                 any_compress = 1;
369               }
370
371             if(!check_compress_algo(COMPRESS_ALGO_ZIP))
372               {
373                 strcat(dummy_string,"Z1 ");
374                 any_compress = 1;
375               }
376
377             /* In case we have no compress algo at all, declare that
378                we prefer no compresssion.  */
379             if (!any_compress)
380               strcat(dummy_string,"Z0 ");
381
382             /* Remove the trailing space.  */
383             if (*dummy_string && dummy_string[strlen (dummy_string)-1] == ' ')
384               dummy_string[strlen (dummy_string)-1] = 0;
385
386             string=dummy_string;
387           }
388       }
389     else if (!ascii_strcasecmp (string, "none"))
390         string = "";
391
392     if(strlen(string))
393       {
394         char *tok,*prefstring;
395
396         prefstring=xstrdup(string); /* need a writable string! */
397
398         while((tok=strsep(&prefstring," ,")))
399           {
400             if((val=string_to_cipher_algo (tok)))
401               {
402                 if(set_one_pref(val,1,tok,sym,&nsym))
403                   rc=-1;
404               }
405             else if((val=string_to_digest_algo (tok)))
406               {
407                 if(set_one_pref(val,2,tok,hash,&nhash))
408                   rc=-1;
409               }
410             else if((val=string_to_compress_algo(tok))>-1)
411               {
412                 if(set_one_pref(val,3,tok,zip,&nzip))
413                   rc=-1;
414               }
415             else if (ascii_strcasecmp(tok,"mdc")==0)
416               mdc=1;
417             else if (ascii_strcasecmp(tok,"no-mdc")==0)
418               mdc=0;
419             else if (ascii_strcasecmp(tok,"ks-modify")==0)
420               modify=1;
421             else if (ascii_strcasecmp(tok,"no-ks-modify")==0)
422               modify=0;
423             else
424               {
425                 log_info (_("invalid item '%s' in preference string\n"),tok);
426                 rc=-1;
427               }
428           }
429
430         xfree(prefstring);
431       }
432
433     if(!rc)
434       {
435         if(personal)
436           {
437             if(personal==PREFTYPE_SYM)
438               {
439                 xfree(opt.personal_cipher_prefs);
440
441                 if(nsym==0)
442                   opt.personal_cipher_prefs=NULL;
443                 else
444                   {
445                     int i;
446
447                     opt.personal_cipher_prefs=
448                       xmalloc(sizeof(prefitem_t *)*(nsym+1));
449
450                     for (i=0; i<nsym; i++)
451                       {
452                         opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
453                         opt.personal_cipher_prefs[i].value = sym[i];
454                       }
455
456                     opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
457                     opt.personal_cipher_prefs[i].value = 0;
458                   }
459               }
460             else if(personal==PREFTYPE_HASH)
461               {
462                 xfree(opt.personal_digest_prefs);
463
464                 if(nhash==0)
465                   opt.personal_digest_prefs=NULL;
466                 else
467                   {
468                     int i;
469
470                     opt.personal_digest_prefs=
471                       xmalloc(sizeof(prefitem_t *)*(nhash+1));
472
473                     for (i=0; i<nhash; i++)
474                       {
475                         opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
476                         opt.personal_digest_prefs[i].value = hash[i];
477                       }
478
479                     opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
480                     opt.personal_digest_prefs[i].value = 0;
481                   }
482               }
483             else if(personal==PREFTYPE_ZIP)
484               {
485                 xfree(opt.personal_compress_prefs);
486
487                 if(nzip==0)
488                   opt.personal_compress_prefs=NULL;
489                 else
490                   {
491                     int i;
492
493                     opt.personal_compress_prefs=
494                       xmalloc(sizeof(prefitem_t *)*(nzip+1));
495
496                     for (i=0; i<nzip; i++)
497                       {
498                         opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
499                         opt.personal_compress_prefs[i].value = zip[i];
500                       }
501
502                     opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
503                     opt.personal_compress_prefs[i].value = 0;
504                   }
505               }
506           }
507         else
508           {
509             memcpy (sym_prefs,  sym,  (nsym_prefs=nsym));
510             memcpy (hash_prefs, hash, (nhash_prefs=nhash));
511             memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
512             mdc_available = mdc;
513             ks_modify = modify;
514             prefs_initialized = 1;
515           }
516       }
517
518     return rc;
519 }
520
521 /* Return a fake user ID containing the preferences.  Caller must
522    free. */
523 PKT_user_id *
524 keygen_get_std_prefs(void)
525 {
526   int i,j=0;
527   PKT_user_id *uid=xmalloc_clear(sizeof(PKT_user_id));
528
529   if(!prefs_initialized)
530     keygen_set_std_prefs(NULL,0);
531
532   uid->ref=1;
533
534   uid->prefs=xmalloc((sizeof(prefitem_t *)*
535                       (nsym_prefs+nhash_prefs+nzip_prefs+1)));
536
537   for(i=0;i<nsym_prefs;i++,j++)
538     {
539       uid->prefs[j].type=PREFTYPE_SYM;
540       uid->prefs[j].value=sym_prefs[i];
541     }
542
543   for(i=0;i<nhash_prefs;i++,j++)
544     {
545       uid->prefs[j].type=PREFTYPE_HASH;
546       uid->prefs[j].value=hash_prefs[i];
547     }
548
549   for(i=0;i<nzip_prefs;i++,j++)
550     {
551       uid->prefs[j].type=PREFTYPE_ZIP;
552       uid->prefs[j].value=zip_prefs[i];
553     }
554
555   uid->prefs[j].type=PREFTYPE_NONE;
556   uid->prefs[j].value=0;
557
558   uid->flags.mdc=mdc_available;
559   uid->flags.ks_modify=ks_modify;
560
561   return uid;
562 }
563
564 static void
565 add_feature_mdc (PKT_signature *sig,int enabled)
566 {
567     const byte *s;
568     size_t n;
569     int i;
570     char *buf;
571
572     s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n );
573     /* Already set or cleared */
574     if (s && n &&
575         ((enabled && (s[0] & 0x01)) || (!enabled && !(s[0] & 0x01))))
576       return;
577
578     if (!s || !n) { /* create a new one */
579         n = 1;
580         buf = xmalloc_clear (n);
581     }
582     else {
583         buf = xmalloc (n);
584         memcpy (buf, s, n);
585     }
586
587     if(enabled)
588       buf[0] |= 0x01; /* MDC feature */
589     else
590       buf[0] &= ~0x01;
591
592     /* Are there any bits set? */
593     for(i=0;i<n;i++)
594       if(buf[i]!=0)
595         break;
596
597     if(i==n)
598       delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
599     else
600       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
601
602     xfree (buf);
603 }
604
605 static void
606 add_keyserver_modify (PKT_signature *sig,int enabled)
607 {
608   const byte *s;
609   size_t n;
610   int i;
611   char *buf;
612
613   /* The keyserver modify flag is a negative flag (i.e. no-modify) */
614   enabled=!enabled;
615
616   s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n );
617   /* Already set or cleared */
618   if (s && n &&
619       ((enabled && (s[0] & 0x80)) || (!enabled && !(s[0] & 0x80))))
620     return;
621
622   if (!s || !n) { /* create a new one */
623     n = 1;
624     buf = xmalloc_clear (n);
625   }
626   else {
627     buf = xmalloc (n);
628     memcpy (buf, s, n);
629   }
630
631   if(enabled)
632     buf[0] |= 0x80; /* no-modify flag */
633   else
634     buf[0] &= ~0x80;
635
636   /* Are there any bits set? */
637   for(i=0;i<n;i++)
638     if(buf[i]!=0)
639       break;
640
641   if(i==n)
642     delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
643   else
644     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
645
646   xfree (buf);
647 }
648
649
650 int
651 keygen_upd_std_prefs (PKT_signature *sig, void *opaque)
652 {
653   (void)opaque;
654
655   if (!prefs_initialized)
656     keygen_set_std_prefs (NULL, 0);
657
658   if (nsym_prefs)
659     build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
660   else
661     {
662       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
663       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
664     }
665
666   if (nhash_prefs)
667     build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
668   else
669     {
670       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
671       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
672     }
673
674   if (nzip_prefs)
675     build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
676   else
677     {
678       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
679       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
680     }
681
682   /* Make sure that the MDC feature flag is set if needed.  */
683   add_feature_mdc (sig,mdc_available);
684   add_keyserver_modify (sig,ks_modify);
685   keygen_add_keyserver_url(sig,NULL);
686
687   return 0;
688 }
689
690
691 /****************
692  * Add preference to the self signature packet.
693  * This is only called for packets with version > 3.
694  */
695 int
696 keygen_add_std_prefs (PKT_signature *sig, void *opaque)
697 {
698   PKT_public_key *pk = opaque;
699
700   do_add_key_flags (sig, pk->pubkey_usage);
701   keygen_add_key_expire (sig, opaque );
702   keygen_upd_std_prefs (sig, opaque);
703   keygen_add_keyserver_url (sig,NULL);
704
705   return 0;
706 }
707
708 int
709 keygen_add_keyserver_url(PKT_signature *sig, void *opaque)
710 {
711   const char *url=opaque;
712
713   if(!url)
714     url=opt.def_keyserver_url;
715
716   if(url)
717     build_sig_subpkt(sig,SIGSUBPKT_PREF_KS,url,strlen(url));
718   else
719     delete_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS);
720
721   return 0;
722 }
723
724 int
725 keygen_add_notations(PKT_signature *sig,void *opaque)
726 {
727   struct notation *notation;
728
729   /* We always start clean */
730   delete_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION);
731   delete_sig_subpkt(sig->unhashed,SIGSUBPKT_NOTATION);
732   sig->flags.notation=0;
733
734   for(notation=opaque;notation;notation=notation->next)
735     if(!notation->flags.ignore)
736       {
737         unsigned char *buf;
738         unsigned int n1,n2;
739
740         n1=strlen(notation->name);
741         if(notation->altvalue)
742           n2=strlen(notation->altvalue);
743         else if(notation->bdat)
744           n2=notation->blen;
745         else
746           n2=strlen(notation->value);
747
748         buf = xmalloc( 8 + n1 + n2 );
749
750         /* human readable or not */
751         buf[0] = notation->bdat?0:0x80;
752         buf[1] = buf[2] = buf[3] = 0;
753         buf[4] = n1 >> 8;
754         buf[5] = n1;
755         buf[6] = n2 >> 8;
756         buf[7] = n2;
757         memcpy(buf+8, notation->name, n1 );
758         if(notation->altvalue)
759           memcpy(buf+8+n1, notation->altvalue, n2 );
760         else if(notation->bdat)
761           memcpy(buf+8+n1, notation->bdat, n2 );
762         else
763           memcpy(buf+8+n1, notation->value, n2 );
764         build_sig_subpkt( sig, SIGSUBPKT_NOTATION |
765                           (notation->flags.critical?SIGSUBPKT_FLAG_CRITICAL:0),
766                           buf, 8+n1+n2 );
767         xfree(buf);
768       }
769
770   return 0;
771 }
772
773 int
774 keygen_add_revkey (PKT_signature *sig, void *opaque)
775 {
776   struct revocation_key *revkey = opaque;
777   byte buf[2+MAX_FINGERPRINT_LEN];
778
779   buf[0] = revkey->class;
780   buf[1] = revkey->algid;
781   memcpy (&buf[2], revkey->fpr, MAX_FINGERPRINT_LEN);
782
783   build_sig_subpkt (sig, SIGSUBPKT_REV_KEY, buf, 2+MAX_FINGERPRINT_LEN);
784
785   /* All sigs with revocation keys set are nonrevocable.  */
786   sig->flags.revocable = 0;
787   buf[0] = 0;
788   build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
789
790   parse_revkeys (sig);
791
792   return 0;
793 }
794
795
796
797 /* Create a back-signature.  If TIMESTAMP is not NULL, use it for the
798    signature creation time.  */
799 gpg_error_t
800 make_backsig (PKT_signature *sig, PKT_public_key *pk,
801               PKT_public_key *sub_pk, PKT_public_key *sub_psk,
802               u32 timestamp, const char *cache_nonce)
803 {
804   gpg_error_t err;
805   PKT_signature *backsig;
806
807   cache_public_key (sub_pk);
808
809   err = make_keysig_packet (&backsig, pk, NULL, sub_pk, sub_psk, 0x19,
810                             0, timestamp, 0, NULL, NULL, cache_nonce);
811   if (err)
812     log_error ("make_keysig_packet failed for backsig: %s\n",
813                gpg_strerror (err));
814   else
815     {
816       /* Get it into a binary packed form. */
817       IOBUF backsig_out = iobuf_temp();
818       PACKET backsig_pkt;
819
820       init_packet (&backsig_pkt);
821       backsig_pkt.pkttype = PKT_SIGNATURE;
822       backsig_pkt.pkt.signature = backsig;
823       err = build_packet (backsig_out, &backsig_pkt);
824       free_packet (&backsig_pkt);
825       if (err)
826         log_error ("build_packet failed for backsig: %s\n", gpg_strerror (err));
827       else
828         {
829           size_t pktlen = 0;
830           byte *buf = iobuf_get_temp_buffer (backsig_out);
831
832           /* Remove the packet header. */
833           if(buf[0]&0x40)
834             {
835               if (buf[1] < 192)
836                 {
837                   pktlen = buf[1];
838                   buf += 2;
839                 }
840               else if(buf[1] < 224)
841                 {
842                   pktlen = (buf[1]-192)*256;
843                   pktlen += buf[2]+192;
844                   buf += 3;
845                 }
846               else if (buf[1] == 255)
847                 {
848                   pktlen = buf32_to_size_t (buf+2);
849                   buf += 6;
850                 }
851               else
852                 BUG ();
853             }
854           else
855             {
856               int mark = 1;
857
858               switch (buf[0]&3)
859                 {
860                 case 3:
861                   BUG ();
862                   break;
863
864                 case 2:
865                   pktlen  = (size_t)buf[mark++] << 24;
866                   pktlen |= buf[mark++] << 16;
867
868                 case 1:
869                   pktlen |= buf[mark++] << 8;
870
871                 case 0:
872                   pktlen |= buf[mark++];
873                 }
874
875               buf += mark;
876             }
877
878           /* Now make the binary blob into a subpacket.  */
879           build_sig_subpkt (sig, SIGSUBPKT_SIGNATURE, buf, pktlen);
880
881           iobuf_close (backsig_out);
882         }
883     }
884
885   return err;
886 }
887
888
889 /* Write a direct key signature to the first key in ROOT using the key
890    PSK.  REVKEY is describes the direct key signature and TIMESTAMP is
891    the timestamp to set on the signature.  */
892 static gpg_error_t
893 write_direct_sig (KBNODE root, PKT_public_key *psk,
894                   struct revocation_key *revkey, u32 timestamp,
895                   const char *cache_nonce)
896 {
897   gpg_error_t err;
898   PACKET *pkt;
899   PKT_signature *sig;
900   KBNODE node;
901   PKT_public_key *pk;
902
903   if (opt.verbose)
904     log_info (_("writing direct signature\n"));
905
906   /* Get the pk packet from the pub_tree. */
907   node = find_kbnode (root, PKT_PUBLIC_KEY);
908   if (!node)
909     BUG ();
910   pk = node->pkt->pkt.public_key;
911
912   /* We have to cache the key, so that the verification of the
913      signature creation is able to retrieve the public key.  */
914   cache_public_key (pk);
915
916   /* Make the signature.  */
917   err = make_keysig_packet (&sig, pk, NULL,NULL, psk, 0x1F,
918                             0, timestamp, 0,
919                             keygen_add_revkey, revkey, cache_nonce);
920   if (err)
921     {
922       log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err) );
923       return err;
924     }
925
926   pkt = xmalloc_clear (sizeof *pkt);
927   pkt->pkttype = PKT_SIGNATURE;
928   pkt->pkt.signature = sig;
929   add_kbnode (root, new_kbnode (pkt));
930   return err;
931 }
932
933
934
935 /* Write a self-signature to the first user id in ROOT using the key
936    PSK.  USE and TIMESTAMP give the extra data we need for the
937    signature.  */
938 static gpg_error_t
939 write_selfsigs (KBNODE root, PKT_public_key *psk,
940                 unsigned int use, u32 timestamp, const char *cache_nonce)
941 {
942   gpg_error_t err;
943   PACKET *pkt;
944   PKT_signature *sig;
945   PKT_user_id *uid;
946   KBNODE node;
947   PKT_public_key *pk;
948
949   if (opt.verbose)
950     log_info (_("writing self signature\n"));
951
952   /* Get the uid packet from the list. */
953   node = find_kbnode (root, PKT_USER_ID);
954   if (!node)
955     BUG(); /* No user id packet in tree.  */
956   uid = node->pkt->pkt.user_id;
957
958   /* Get the pk packet from the pub_tree. */
959   node = find_kbnode (root, PKT_PUBLIC_KEY);
960   if (!node)
961     BUG();
962   pk = node->pkt->pkt.public_key;
963
964   /* The usage has not yet been set - do it now. */
965   pk->pubkey_usage = use;
966
967   /* We have to cache the key, so that the verification of the
968      signature creation is able to retrieve the public key.  */
969   cache_public_key (pk);
970
971   /* Make the signature.  */
972   err = make_keysig_packet (&sig, pk, uid, NULL, psk, 0x13,
973                             0, timestamp, 0,
974                             keygen_add_std_prefs, pk, cache_nonce);
975   if (err)
976     {
977       log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err));
978       return err;
979     }
980
981   pkt = xmalloc_clear (sizeof *pkt);
982   pkt->pkttype = PKT_SIGNATURE;
983   pkt->pkt.signature = sig;
984   add_kbnode (root, new_kbnode (pkt));
985
986   return err;
987 }
988
989
990 /* Write the key binding signature.  If TIMESTAMP is not NULL use the
991    signature creation time.  PRI_PSK is the key use for signing.
992    SUB_PSK is a key used to create a back-signature; that one is only
993    used if USE has the PUBKEY_USAGE_SIG capability.  */
994 static int
995 write_keybinding (KBNODE root, PKT_public_key *pri_psk, PKT_public_key *sub_psk,
996                   unsigned int use, u32 timestamp, const char *cache_nonce)
997 {
998   gpg_error_t err;
999   PACKET *pkt;
1000   PKT_signature *sig;
1001   KBNODE node;
1002   PKT_public_key *pri_pk, *sub_pk;
1003   struct opaque_data_usage_and_pk oduap;
1004
1005   if (opt.verbose)
1006     log_info(_("writing key binding signature\n"));
1007
1008   /* Get the primary pk packet from the tree.  */
1009   node = find_kbnode (root, PKT_PUBLIC_KEY);
1010   if (!node)
1011     BUG();
1012   pri_pk = node->pkt->pkt.public_key;
1013
1014   /* We have to cache the key, so that the verification of the
1015    * signature creation is able to retrieve the public key.  */
1016   cache_public_key (pri_pk);
1017
1018   /* Find the last subkey. */
1019   sub_pk = NULL;
1020   for (node = root; node; node = node->next )
1021     {
1022       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1023         sub_pk = node->pkt->pkt.public_key;
1024     }
1025   if (!sub_pk)
1026     BUG();
1027
1028   /* Make the signature.  */
1029   oduap.usage = use;
1030   oduap.pk = sub_pk;
1031   err = make_keysig_packet (&sig, pri_pk, NULL, sub_pk, pri_psk, 0x18,
1032                             0, timestamp, 0,
1033                             keygen_add_key_flags_and_expire, &oduap,
1034                             cache_nonce);
1035   if (err)
1036     {
1037       log_error ("make_keysig_packeto failed: %s\n", gpg_strerror (err));
1038       return err;
1039     }
1040
1041   /* Make a backsig.  */
1042   if (use & PUBKEY_USAGE_SIG)
1043     {
1044       err = make_backsig (sig, pri_pk, sub_pk, sub_psk, timestamp, cache_nonce);
1045       if (err)
1046         return err;
1047     }
1048
1049   pkt = xmalloc_clear ( sizeof *pkt );
1050   pkt->pkttype = PKT_SIGNATURE;
1051   pkt->pkt.signature = sig;
1052   add_kbnode (root, new_kbnode (pkt) );
1053   return err;
1054 }
1055
1056
1057 static gpg_error_t
1058 ecckey_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp, int algo)
1059 {
1060   gpg_error_t err;
1061   gcry_sexp_t list, l2;
1062   char *curve;
1063   int i;
1064   const char *oidstr;
1065   unsigned int nbits;
1066
1067   array[0] = NULL;
1068   array[1] = NULL;
1069   array[2] = NULL;
1070
1071   list = gcry_sexp_find_token (sexp, "public-key", 0);
1072   if (!list)
1073     return gpg_error (GPG_ERR_INV_OBJ);
1074   l2 = gcry_sexp_cadr (list);
1075   gcry_sexp_release (list);
1076   list = l2;
1077   if (!list)
1078     return gpg_error (GPG_ERR_NO_OBJ);
1079
1080   l2 = gcry_sexp_find_token (list, "curve", 0);
1081   if (!l2)
1082     {
1083       err = gpg_error (GPG_ERR_NO_OBJ);
1084       goto leave;
1085     }
1086   curve = gcry_sexp_nth_string (l2, 1);
1087   if (!curve)
1088     {
1089       err = gpg_error (GPG_ERR_NO_OBJ);
1090       goto leave;
1091     }
1092   gcry_sexp_release (l2);
1093   oidstr = openpgp_curve_to_oid (curve, &nbits);
1094   if (!oidstr)
1095     {
1096       /* That can't happen because we used one of the curves
1097          gpg_curve_to_oid knows about.  */
1098       err = gpg_error (GPG_ERR_INV_OBJ);
1099       goto leave;
1100     }
1101   err = openpgp_oid_from_str (oidstr, &array[0]);
1102   if (err)
1103     goto leave;
1104
1105   l2 = gcry_sexp_find_token (list, "q", 0);
1106   if (!l2)
1107     {
1108       err = gpg_error (GPG_ERR_NO_OBJ);
1109       goto leave;
1110     }
1111   array[1] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1112   gcry_sexp_release (l2);
1113   if (!array[1])
1114     {
1115       err = gpg_error (GPG_ERR_INV_OBJ);
1116       goto leave;
1117     }
1118   gcry_sexp_release (list);
1119
1120   if (algo == PUBKEY_ALGO_ECDH)
1121     {
1122       array[2] = pk_ecdh_default_params (nbits);
1123       if (!array[2])
1124         {
1125           err = gpg_error_from_syserror ();
1126           goto leave;
1127         }
1128     }
1129
1130  leave:
1131   if (err)
1132     {
1133       for (i=0; i < 3; i++)
1134         {
1135           gcry_mpi_release (array[i]);
1136           array[i] = NULL;
1137         }
1138     }
1139   return err;
1140 }
1141
1142
1143 /* Extract key parameters from SEXP and store them in ARRAY.  ELEMS is
1144    a string where each character denotes a parameter name.  TOPNAME is
1145    the name of the top element above the elements.  */
1146 static int
1147 key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
1148                const char *topname, const char *elems)
1149 {
1150   gcry_sexp_t list, l2;
1151   const char *s;
1152   int i, idx;
1153   int rc = 0;
1154
1155   list = gcry_sexp_find_token (sexp, topname, 0);
1156   if (!list)
1157     return gpg_error (GPG_ERR_INV_OBJ);
1158   l2 = gcry_sexp_cadr (list);
1159   gcry_sexp_release (list);
1160   list = l2;
1161   if (!list)
1162     return gpg_error (GPG_ERR_NO_OBJ);
1163
1164   for (idx=0,s=elems; *s; s++, idx++)
1165     {
1166       l2 = gcry_sexp_find_token (list, s, 1);
1167       if (!l2)
1168         {
1169           rc = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
1170           goto leave;
1171         }
1172       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1173       gcry_sexp_release (l2);
1174       if (!array[idx])
1175         {
1176           rc = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
1177           goto leave;
1178         }
1179     }
1180   gcry_sexp_release (list);
1181
1182  leave:
1183   if (rc)
1184     {
1185       for (i=0; i<idx; i++)
1186         {
1187           gcry_mpi_release (array[i]);
1188           array[i] = NULL;
1189         }
1190       gcry_sexp_release (list);
1191     }
1192   return rc;
1193 }
1194
1195
1196 /* Create a keyblock using the given KEYGRIP.  ALGO is the OpenPGP
1197    algorithm of that keygrip.  */
1198 static int
1199 do_create_from_keygrip (ctrl_t ctrl, int algo, const char *hexkeygrip,
1200                         kbnode_t pub_root, u32 timestamp, u32 expireval,
1201                         int is_subkey)
1202 {
1203   int err;
1204   PACKET *pkt;
1205   PKT_public_key *pk;
1206   gcry_sexp_t s_key;
1207   const char *algoelem;
1208
1209   if (hexkeygrip[0] == '&')
1210     hexkeygrip++;
1211
1212   switch (algo)
1213     {
1214     case PUBKEY_ALGO_RSA:       algoelem = "ne"; break;
1215     case PUBKEY_ALGO_DSA:       algoelem = "pqgy"; break;
1216     case PUBKEY_ALGO_ELGAMAL_E: algoelem = "pgy"; break;
1217     case PUBKEY_ALGO_ECDH:
1218     case PUBKEY_ALGO_ECDSA:     algoelem = ""; break;
1219     case PUBKEY_ALGO_EDDSA:     algoelem = ""; break;
1220     default: return gpg_error (GPG_ERR_INTERNAL);
1221     }
1222
1223
1224   /* Ask the agent for the public key matching HEXKEYGRIP.  */
1225   {
1226     unsigned char *public;
1227
1228     err = agent_readkey (ctrl, 0, hexkeygrip, &public);
1229     if (err)
1230       return err;
1231     err = gcry_sexp_sscan (&s_key, NULL,
1232                            public, gcry_sexp_canon_len (public, 0, NULL, NULL));
1233     xfree (public);
1234     if (err)
1235       return err;
1236   }
1237
1238   /* Build a public key packet.  */
1239   pk = xtrycalloc (1, sizeof *pk);
1240   if (!pk)
1241     {
1242       err = gpg_error_from_syserror ();
1243       gcry_sexp_release (s_key);
1244       return err;
1245     }
1246
1247   pk->timestamp = timestamp;
1248   pk->version = 4;
1249   if (expireval)
1250     pk->expiredate = pk->timestamp + expireval;
1251   pk->pubkey_algo = algo;
1252
1253   if (algo == PUBKEY_ALGO_ECDSA
1254       || algo == PUBKEY_ALGO_EDDSA
1255       || algo == PUBKEY_ALGO_ECDH )
1256     err = ecckey_from_sexp (pk->pkey, s_key, algo);
1257   else
1258     err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
1259   if (err)
1260     {
1261       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
1262       gcry_sexp_release (s_key);
1263       free_public_key (pk);
1264       return err;
1265     }
1266   gcry_sexp_release (s_key);
1267
1268   pkt = xtrycalloc (1, sizeof *pkt);
1269   if (!pkt)
1270     {
1271       err = gpg_error_from_syserror ();
1272       free_public_key (pk);
1273       return err;
1274     }
1275
1276   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1277   pkt->pkt.public_key = pk;
1278   add_kbnode (pub_root, new_kbnode (pkt));
1279
1280   return 0;
1281 }
1282
1283
1284 /* Common code for the key generation function gen_xxx.  */
1285 static int
1286 common_gen (const char *keyparms, int algo, const char *algoelem,
1287             kbnode_t pub_root, u32 timestamp, u32 expireval, int is_subkey,
1288             int keygen_flags, const char *passphrase, char **cache_nonce_addr)
1289 {
1290   int err;
1291   PACKET *pkt;
1292   PKT_public_key *pk;
1293   gcry_sexp_t s_key;
1294
1295   err = agent_genkey (NULL, cache_nonce_addr, keyparms,
1296                       !!(keygen_flags & KEYGEN_FLAG_NO_PROTECTION),
1297                       passphrase,
1298                       &s_key);
1299   if (err)
1300     {
1301       log_error ("agent_genkey failed: %s\n", gpg_strerror (err) );
1302       return err;
1303     }
1304
1305   pk = xtrycalloc (1, sizeof *pk);
1306   if (!pk)
1307     {
1308       err = gpg_error_from_syserror ();
1309       gcry_sexp_release (s_key);
1310       return err;
1311     }
1312
1313   pk->timestamp = timestamp;
1314   pk->version = 4;
1315   if (expireval)
1316     pk->expiredate = pk->timestamp + expireval;
1317   pk->pubkey_algo = algo;
1318
1319   if (algo == PUBKEY_ALGO_ECDSA
1320       || algo == PUBKEY_ALGO_EDDSA
1321       || algo == PUBKEY_ALGO_ECDH )
1322     err = ecckey_from_sexp (pk->pkey, s_key, algo);
1323   else
1324     err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
1325   if (err)
1326     {
1327       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
1328       gcry_sexp_release (s_key);
1329       free_public_key (pk);
1330       return err;
1331     }
1332   gcry_sexp_release (s_key);
1333
1334   pkt = xtrycalloc (1, sizeof *pkt);
1335   if (!pkt)
1336     {
1337       err = gpg_error_from_syserror ();
1338       free_public_key (pk);
1339       return err;
1340     }
1341
1342   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1343   pkt->pkt.public_key = pk;
1344   add_kbnode (pub_root, new_kbnode (pkt));
1345
1346   return 0;
1347 }
1348
1349
1350 /*
1351  * Generate an Elgamal key.
1352  */
1353 static int
1354 gen_elg (int algo, unsigned int nbits, KBNODE pub_root,
1355          u32 timestamp, u32 expireval, int is_subkey,
1356          int keygen_flags, const char *passphrase, char **cache_nonce_addr)
1357 {
1358   int err;
1359   char *keyparms;
1360   char nbitsstr[35];
1361
1362   assert (is_ELGAMAL (algo));
1363
1364   if (nbits < 1024)
1365     {
1366       nbits = 2048;
1367       log_info (_("keysize invalid; using %u bits\n"), nbits );
1368     }
1369   else if (nbits > 4096)
1370     {
1371       nbits = 4096;
1372       log_info (_("keysize invalid; using %u bits\n"), nbits );
1373     }
1374
1375   if ((nbits % 32))
1376     {
1377       nbits = ((nbits + 31) / 32) * 32;
1378       log_info (_("keysize rounded up to %u bits\n"), nbits );
1379     }
1380
1381   /* Note that we use transient-key only if no-protection has also
1382      been enabled.  */
1383   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1384   keyparms = xtryasprintf ("(genkey(%s(nbits %zu:%s)%s))",
1385                            algo == GCRY_PK_ELG_E ? "openpgp-elg" :
1386                            algo == GCRY_PK_ELG   ? "elg" : "x-oops" ,
1387                            strlen (nbitsstr), nbitsstr,
1388                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1389                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1390                            "(transient-key)" : "" );
1391   if (!keyparms)
1392     err = gpg_error_from_syserror ();
1393   else
1394     {
1395       err = common_gen (keyparms, algo, "pgy",
1396                         pub_root, timestamp, expireval, is_subkey,
1397                         keygen_flags, passphrase, cache_nonce_addr);
1398       xfree (keyparms);
1399     }
1400
1401   return err;
1402 }
1403
1404
1405 /*
1406  * Generate an DSA key
1407  */
1408 static gpg_error_t
1409 gen_dsa (unsigned int nbits, KBNODE pub_root,
1410          u32 timestamp, u32 expireval, int is_subkey,
1411          int keygen_flags, const char *passphrase, char **cache_nonce_addr)
1412 {
1413   int err;
1414   unsigned int qbits;
1415   char *keyparms;
1416   char nbitsstr[35];
1417   char qbitsstr[35];
1418
1419   if (nbits < 768)
1420     {
1421       nbits = 2048;
1422       log_info(_("keysize invalid; using %u bits\n"), nbits );
1423     }
1424   else if ( nbits > 3072 )
1425     {
1426       nbits = 3072;
1427       log_info(_("keysize invalid; using %u bits\n"), nbits );
1428     }
1429
1430   if( (nbits % 64) )
1431     {
1432       nbits = ((nbits + 63) / 64) * 64;
1433       log_info(_("keysize rounded up to %u bits\n"), nbits );
1434     }
1435
1436   /* To comply with FIPS rules we round up to the next value unless in
1437      expert mode.  */
1438   if (!opt.expert && nbits > 1024 && (nbits % 1024))
1439     {
1440       nbits = ((nbits + 1023) / 1024) * 1024;
1441       log_info(_("keysize rounded up to %u bits\n"), nbits );
1442     }
1443
1444   /*
1445     Figure out a q size based on the key size.  FIPS 180-3 says:
1446
1447     L = 1024, N = 160
1448     L = 2048, N = 224
1449     L = 2048, N = 256
1450     L = 3072, N = 256
1451
1452     2048/256 is an odd pair since there is also a 2048/224 and
1453     3072/256.  Matching sizes is not a very exact science.
1454
1455     We'll do 256 qbits for nbits over 2047, 224 for nbits over 1024
1456     but less than 2048, and 160 for 1024 (DSA1).
1457   */
1458
1459   if (nbits > 2047)
1460     qbits = 256;
1461   else if ( nbits > 1024)
1462     qbits = 224;
1463   else
1464     qbits = 160;
1465
1466   if (qbits != 160 )
1467     log_info (_("WARNING: some OpenPGP programs can't"
1468                 " handle a DSA key with this digest size\n"));
1469
1470   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1471   snprintf (qbitsstr, sizeof qbitsstr, "%u", qbits);
1472   keyparms = xtryasprintf ("(genkey(dsa(nbits %zu:%s)(qbits %zu:%s)%s))",
1473                            strlen (nbitsstr), nbitsstr,
1474                            strlen (qbitsstr), qbitsstr,
1475                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1476                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1477                            "(transient-key)" : "" );
1478   if (!keyparms)
1479     err = gpg_error_from_syserror ();
1480   else
1481     {
1482       err = common_gen (keyparms, PUBKEY_ALGO_DSA, "pqgy",
1483                         pub_root, timestamp, expireval, is_subkey,
1484                         keygen_flags, passphrase, cache_nonce_addr);
1485       xfree (keyparms);
1486     }
1487
1488   return err;
1489 }
1490
1491
1492
1493 /*
1494  * Generate an ECC key
1495  */
1496 static gpg_error_t
1497 gen_ecc (int algo, const char *curve, kbnode_t pub_root,
1498          u32 timestamp, u32 expireval, int is_subkey,
1499          int keygen_flags, const char *passphrase, char **cache_nonce_addr)
1500 {
1501   gpg_error_t err;
1502   char *keyparms;
1503
1504   assert (algo == PUBKEY_ALGO_ECDSA
1505           || algo == PUBKEY_ALGO_EDDSA
1506           || algo == PUBKEY_ALGO_ECDH);
1507
1508   if (!curve || !*curve)
1509     return gpg_error (GPG_ERR_UNKNOWN_CURVE);
1510
1511   /* Note that we use the "comp" flag with EdDSA to request the use of
1512      a 0x40 compression prefix octet.  */
1513   if (algo == PUBKEY_ALGO_EDDSA)
1514     keyparms = xtryasprintf
1515       ("(genkey(ecc(curve %zu:%s)(flags eddsa comp%s)))",
1516        strlen (curve), curve,
1517        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1518          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1519         " transient-key" : ""));
1520   else if (algo == PUBKEY_ALGO_ECDH && !strcmp (curve, "Curve25519"))
1521     keyparms = xtryasprintf
1522       ("(genkey(ecc(curve %zu:%s)(flags djb-tweak comp%s)))",
1523        strlen (curve), curve,
1524        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1525          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1526         " transient-key" : ""));
1527   else
1528     keyparms = xtryasprintf
1529       ("(genkey(ecc(curve %zu:%s)(flags nocomp%s)))",
1530        strlen (curve), curve,
1531        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1532          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1533         " transient-key" : ""));
1534
1535   if (!keyparms)
1536     err = gpg_error_from_syserror ();
1537   else
1538     {
1539       err = common_gen (keyparms, algo, "",
1540                         pub_root, timestamp, expireval, is_subkey,
1541                         keygen_flags, passphrase, cache_nonce_addr);
1542       xfree (keyparms);
1543     }
1544
1545   return err;
1546 }
1547
1548
1549 /*
1550  * Generate an RSA key.
1551  */
1552 static int
1553 gen_rsa (int algo, unsigned int nbits, KBNODE pub_root,
1554          u32 timestamp, u32 expireval, int is_subkey,
1555          int keygen_flags, const char *passphrase, char **cache_nonce_addr)
1556 {
1557   int err;
1558   char *keyparms;
1559   char nbitsstr[35];
1560   const unsigned maxsize = (opt.flags.large_rsa ? 8192 : 4096);
1561
1562   assert (is_RSA(algo));
1563
1564   if (!nbits)
1565     nbits = DEFAULT_STD_KEYSIZE;
1566
1567   if (nbits < 1024)
1568     {
1569       nbits = 2048;
1570       log_info (_("keysize invalid; using %u bits\n"), nbits );
1571     }
1572   else if (nbits > maxsize)
1573     {
1574       nbits = maxsize;
1575       log_info (_("keysize invalid; using %u bits\n"), nbits );
1576     }
1577
1578   if ((nbits % 32))
1579     {
1580       nbits = ((nbits + 31) / 32) * 32;
1581       log_info (_("keysize rounded up to %u bits\n"), nbits );
1582     }
1583
1584   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1585   keyparms = xtryasprintf ("(genkey(rsa(nbits %zu:%s)%s))",
1586                            strlen (nbitsstr), nbitsstr,
1587                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
1588                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
1589                            "(transient-key)" : "" );
1590   if (!keyparms)
1591     err = gpg_error_from_syserror ();
1592   else
1593     {
1594       err = common_gen (keyparms, algo, "ne",
1595                         pub_root, timestamp, expireval, is_subkey,
1596                         keygen_flags, passphrase, cache_nonce_addr);
1597       xfree (keyparms);
1598     }
1599
1600   return err;
1601 }
1602
1603
1604 /****************
1605  * check valid days:
1606  * return 0 on error or the multiplier
1607  */
1608 static int
1609 check_valid_days( const char *s )
1610 {
1611     if( !digitp(s) )
1612         return 0;
1613     for( s++; *s; s++)
1614         if( !digitp(s) )
1615             break;
1616     if( !*s )
1617         return 1;
1618     if( s[1] )
1619         return 0; /* e.g. "2323wc" */
1620     if( *s == 'd' || *s == 'D' )
1621         return 1;
1622     if( *s == 'w' || *s == 'W' )
1623         return 7;
1624     if( *s == 'm' || *s == 'M' )
1625         return 30;
1626     if( *s == 'y' || *s == 'Y' )
1627         return 365;
1628     return 0;
1629 }
1630
1631
1632 static void
1633 print_key_flags(int flags)
1634 {
1635   if(flags&PUBKEY_USAGE_SIG)
1636     tty_printf("%s ",_("Sign"));
1637
1638   if(flags&PUBKEY_USAGE_CERT)
1639     tty_printf("%s ",_("Certify"));
1640
1641   if(flags&PUBKEY_USAGE_ENC)
1642     tty_printf("%s ",_("Encrypt"));
1643
1644   if(flags&PUBKEY_USAGE_AUTH)
1645     tty_printf("%s ",_("Authenticate"));
1646 }
1647
1648
1649 /* Returns the key flags */
1650 static unsigned int
1651 ask_key_flags(int algo,int subkey)
1652 {
1653   /* TRANSLATORS: Please use only plain ASCII characters for the
1654      translation.  If this is not possible use single digits.  The
1655      string needs to 8 bytes long. Here is a description of the
1656      functions:
1657
1658        s = Toggle signing capability
1659        e = Toggle encryption capability
1660        a = Toggle authentication capability
1661        q = Finish
1662   */
1663   const char *togglers=_("SsEeAaQq");
1664   char *answer=NULL;
1665   const char *s;
1666   unsigned int current=0;
1667   unsigned int possible=openpgp_pk_algo_usage(algo);
1668
1669   if ( strlen(togglers) != 8 )
1670     {
1671       tty_printf ("NOTE: Bad translation at %s:%d. "
1672                   "Please report.\n", __FILE__, __LINE__);
1673       togglers = "11223300";
1674     }
1675
1676   /* Only primary keys may certify. */
1677   if(subkey)
1678     possible&=~PUBKEY_USAGE_CERT;
1679
1680   /* Preload the current set with the possible set, minus
1681      authentication, since nobody really uses auth yet. */
1682   current=possible&~PUBKEY_USAGE_AUTH;
1683
1684   for(;;)
1685     {
1686       tty_printf("\n");
1687       tty_printf(_("Possible actions for a %s key: "),
1688                  openpgp_pk_algo_name (algo));
1689       print_key_flags(possible);
1690       tty_printf("\n");
1691       tty_printf(_("Current allowed actions: "));
1692       print_key_flags(current);
1693       tty_printf("\n\n");
1694
1695       if(possible&PUBKEY_USAGE_SIG)
1696         tty_printf(_("   (%c) Toggle the sign capability\n"),
1697                    togglers[0]);
1698       if(possible&PUBKEY_USAGE_ENC)
1699         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
1700                    togglers[2]);
1701       if(possible&PUBKEY_USAGE_AUTH)
1702         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
1703                    togglers[4]);
1704
1705       tty_printf(_("   (%c) Finished\n"),togglers[6]);
1706       tty_printf("\n");
1707
1708       xfree(answer);
1709       answer = cpr_get("keygen.flags",_("Your selection? "));
1710       cpr_kill_prompt();
1711
1712       if (*answer == '=')
1713         {
1714           /* Hack to allow direct entry of the capabilities.  */
1715           current = 0;
1716           for (s=answer+1; *s; s++)
1717             {
1718               if ((*s == 's' || *s == 'S') && (possible&PUBKEY_USAGE_SIG))
1719                 current |= PUBKEY_USAGE_SIG;
1720               else if ((*s == 'e' || *s == 'E') && (possible&PUBKEY_USAGE_ENC))
1721                 current |= PUBKEY_USAGE_ENC;
1722               else if ((*s == 'a' || *s == 'A') && (possible&PUBKEY_USAGE_AUTH))
1723                 current |= PUBKEY_USAGE_AUTH;
1724               else if (!subkey && *s == 'c')
1725                 {
1726                   /* Accept 'c' for the primary key because USAGE_CERT
1727                      will will be set anyway.  This is for folks who
1728                      want to experiment with a cert-only primary key.  */
1729                   current |= PUBKEY_USAGE_CERT;
1730                 }
1731             }
1732           break;
1733         }
1734       else if (strlen(answer)>1)
1735         tty_printf(_("Invalid selection.\n"));
1736       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1737         break;
1738       else if((*answer==togglers[0] || *answer==togglers[1])
1739               && possible&PUBKEY_USAGE_SIG)
1740         {
1741           if(current&PUBKEY_USAGE_SIG)
1742             current&=~PUBKEY_USAGE_SIG;
1743           else
1744             current|=PUBKEY_USAGE_SIG;
1745         }
1746       else if((*answer==togglers[2] || *answer==togglers[3])
1747               && possible&PUBKEY_USAGE_ENC)
1748         {
1749           if(current&PUBKEY_USAGE_ENC)
1750             current&=~PUBKEY_USAGE_ENC;
1751           else
1752             current|=PUBKEY_USAGE_ENC;
1753         }
1754       else if((*answer==togglers[4] || *answer==togglers[5])
1755               && possible&PUBKEY_USAGE_AUTH)
1756         {
1757           if(current&PUBKEY_USAGE_AUTH)
1758             current&=~PUBKEY_USAGE_AUTH;
1759           else
1760             current|=PUBKEY_USAGE_AUTH;
1761         }
1762       else
1763         tty_printf(_("Invalid selection.\n"));
1764     }
1765
1766   xfree(answer);
1767
1768   return current;
1769 }
1770
1771
1772 /* Check whether we have a key for the key with HEXGRIP.  Returns 0 if
1773    there is no such key or the OpenPGP algo number for the key.  */
1774 static int
1775 check_keygrip (ctrl_t ctrl, const char *hexgrip)
1776 {
1777   gpg_error_t err;
1778   unsigned char *public;
1779   size_t publiclen;
1780   const char *algostr;
1781
1782   if (hexgrip[0] == '&')
1783     hexgrip++;
1784
1785   err = agent_readkey (ctrl, 0, hexgrip, &public);
1786   if (err)
1787     return 0;
1788   publiclen = gcry_sexp_canon_len (public, 0, NULL, NULL);
1789
1790   get_pk_algo_from_canon_sexp (public, publiclen, &algostr);
1791   xfree (public);
1792
1793   /* FIXME: Mapping of ECC algorithms is probably not correct. */
1794   if (!algostr)
1795     return 0;
1796   else if (!strcmp (algostr, "rsa"))
1797     return PUBKEY_ALGO_RSA;
1798   else if (!strcmp (algostr, "dsa"))
1799     return PUBKEY_ALGO_DSA;
1800   else if (!strcmp (algostr, "elg"))
1801     return PUBKEY_ALGO_ELGAMAL_E;
1802   else if (!strcmp (algostr, "ecc"))
1803     return PUBKEY_ALGO_ECDH;
1804   else if (!strcmp (algostr, "ecdsa"))
1805     return PUBKEY_ALGO_ECDSA;
1806   else if (!strcmp (algostr, "eddsa"))
1807     return PUBKEY_ALGO_EDDSA;
1808   else
1809     return 0;
1810 }
1811
1812
1813
1814 /* Ask for an algorithm.  The function returns the algorithm id to
1815  * create. If ADDMODE is false the function won't show an option to
1816  * create the primary and subkey combined and won't set R_USAGE
1817  * either.  If a combined algorithm has been selected, the subkey
1818  * algorithm is stored at R_SUBKEY_ALGO.  If R_KEYGRIP is given, the
1819  * user has the choice to enter the keygrip of an existing key.  That
1820  * keygrip is then stored at this address.  The caller needs to free
1821  * it. */
1822 static int
1823 ask_algo (ctrl_t ctrl, int addmode, int *r_subkey_algo, unsigned int *r_usage,
1824           char **r_keygrip)
1825 {
1826   char *keygrip = NULL;
1827   char *answer = NULL;
1828   int algo;
1829   int dummy_algo;
1830
1831   if (!r_subkey_algo)
1832     r_subkey_algo = &dummy_algo;
1833
1834   tty_printf (_("Please select what kind of key you want:\n"));
1835
1836 #if GPG_USE_RSA
1837   if (!addmode)
1838     tty_printf (_("   (%d) RSA and RSA (default)\n"), 1 );
1839 #endif
1840
1841   if (!addmode)
1842     tty_printf (_("   (%d) DSA and Elgamal\n"), 2 );
1843
1844   tty_printf (_("   (%d) DSA (sign only)\n"), 3 );
1845 #if GPG_USE_RSA
1846   tty_printf (_("   (%d) RSA (sign only)\n"), 4 );
1847 #endif
1848
1849   if (addmode)
1850     {
1851       tty_printf (_("   (%d) Elgamal (encrypt only)\n"), 5 );
1852 #if GPG_USE_RSA
1853       tty_printf (_("   (%d) RSA (encrypt only)\n"), 6 );
1854 #endif
1855     }
1856   if (opt.expert)
1857     {
1858       tty_printf (_("   (%d) DSA (set your own capabilities)\n"), 7 );
1859 #if GPG_USE_RSA
1860       tty_printf (_("   (%d) RSA (set your own capabilities)\n"), 8 );
1861 #endif
1862     }
1863
1864 #if GPG_USE_ECDSA || GPG_USE_ECDH || GPG_USE_EDDSA
1865   if (opt.expert && !addmode)
1866     tty_printf (_("   (%d) ECC and ECC\n"), 9 );
1867   if (opt.expert)
1868     tty_printf (_("  (%d) ECC (sign only)\n"), 10 );
1869   if (opt.expert)
1870     tty_printf (_("  (%d) ECC (set your own capabilities)\n"), 11 );
1871   if (opt.expert && addmode)
1872     tty_printf (_("  (%d) ECC (encrypt only)\n"), 12 );
1873 #endif
1874
1875   if (opt.expert && r_keygrip)
1876     tty_printf (_("  (%d) Existing key\n"), 13 );
1877
1878   for (;;)
1879     {
1880       *r_usage = 0;
1881       *r_subkey_algo = 0;
1882       xfree (answer);
1883       answer = cpr_get ("keygen.algo", _("Your selection? "));
1884       cpr_kill_prompt ();
1885       algo = *answer? atoi (answer) : 1;
1886       if ((algo == 1 || !strcmp (answer, "rsa+rsa")) && !addmode)
1887         {
1888           algo = PUBKEY_ALGO_RSA;
1889           *r_subkey_algo = PUBKEY_ALGO_RSA;
1890           break;
1891         }
1892       else if ((algo == 2 || !strcmp (answer, "dsa+elg")) && !addmode)
1893         {
1894           algo = PUBKEY_ALGO_DSA;
1895           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
1896           break;
1897         }
1898       else if (algo == 3 || !strcmp (answer, "dsa"))
1899         {
1900           algo = PUBKEY_ALGO_DSA;
1901           *r_usage = PUBKEY_USAGE_SIG;
1902           break;
1903         }
1904       else if (algo == 4 || !strcmp (answer, "rsa/s"))
1905         {
1906           algo = PUBKEY_ALGO_RSA;
1907           *r_usage = PUBKEY_USAGE_SIG;
1908           break;
1909         }
1910       else if ((algo == 5 || !strcmp (answer, "elg")) && addmode)
1911         {
1912           algo = PUBKEY_ALGO_ELGAMAL_E;
1913           *r_usage = PUBKEY_USAGE_ENC;
1914           break;
1915         }
1916       else if ((algo == 6 || !strcmp (answer, "rsa/e")) && addmode)
1917         {
1918           algo = PUBKEY_ALGO_RSA;
1919           *r_usage = PUBKEY_USAGE_ENC;
1920           break;
1921         }
1922       else if ((algo == 7 || !strcmp (answer, "dsa/*")) && opt.expert)
1923         {
1924           algo = PUBKEY_ALGO_DSA;
1925           *r_usage = ask_key_flags (algo, addmode);
1926           break;
1927         }
1928       else if ((algo == 8 || !strcmp (answer, "rsa/*")) && opt.expert)
1929         {
1930           algo = PUBKEY_ALGO_RSA;
1931           *r_usage = ask_key_flags (algo, addmode);
1932           break;
1933         }
1934       else if ((algo == 9 || !strcmp (answer, "ecc+ecc"))
1935                && opt.expert && !addmode)
1936         {
1937           algo = PUBKEY_ALGO_ECDSA;
1938           *r_subkey_algo = PUBKEY_ALGO_ECDH;
1939           break;
1940         }
1941       else if ((algo == 10 || !strcmp (answer, "ecc/s")) && opt.expert)
1942         {
1943           algo = PUBKEY_ALGO_ECDSA;
1944           *r_usage = PUBKEY_USAGE_SIG;
1945           break;
1946         }
1947       else if ((algo == 11 || !strcmp (answer, "ecc/*")) && opt.expert)
1948         {
1949           algo = PUBKEY_ALGO_ECDSA;
1950           *r_usage = ask_key_flags (algo, addmode);
1951           break;
1952         }
1953       else if ((algo == 12 || !strcmp (answer, "ecc/e"))
1954                && opt.expert && addmode)
1955         {
1956           algo = PUBKEY_ALGO_ECDH;
1957           *r_usage = PUBKEY_USAGE_ENC;
1958           break;
1959         }
1960       else if ((algo == 13 || !strcmp (answer, "keygrip"))
1961                && opt.expert && r_keygrip)
1962         {
1963           for (;;)
1964             {
1965               xfree (answer);
1966               answer = tty_get (_("Enter the keygrip: "));
1967               tty_kill_prompt ();
1968               trim_spaces (answer);
1969               if (!*answer)
1970                 {
1971                   xfree (answer);
1972                   answer = NULL;
1973                   continue;
1974                 }
1975
1976               if (strlen (answer) != 40 &&
1977                        !(answer[0] == '&' && strlen (answer+1) == 40))
1978                 tty_printf
1979                   (_("Not a valid keygrip (expecting 40 hex digits)\n"));
1980               else if (!(algo = check_keygrip (ctrl, answer)) )
1981                 tty_printf (_("No key with this keygrip\n"));
1982               else
1983                 break; /* Okay.  */
1984             }
1985           xfree (keygrip);
1986           keygrip = answer;
1987           answer = NULL;
1988           *r_usage = ask_key_flags (algo, addmode);
1989           break;
1990         }
1991       else
1992         tty_printf (_("Invalid selection.\n"));
1993
1994     }
1995
1996   xfree(answer);
1997   if (r_keygrip)
1998     *r_keygrip = keygrip;
1999   return algo;
2000 }
2001
2002
2003 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
2004    is not 0, the function asks for the size of the encryption
2005    subkey. */
2006 static unsigned
2007 ask_keysize (int algo, unsigned int primary_keysize)
2008 {
2009   unsigned int nbits;
2010   unsigned int min = 1024;
2011   unsigned int def = DEFAULT_STD_KEYSIZE;
2012   unsigned int max = 4096;
2013   int for_subkey = !!primary_keysize;
2014   int autocomp = 0;
2015
2016   if (primary_keysize && !opt.expert)
2017     {
2018       /* Deduce the subkey size from the primary key size.  */
2019       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
2020         nbits = 3072; /* For performance reasons we don't support more
2021                          than 3072 bit DSA.  However we won't see this
2022                          case anyway because DSA can't be used as an
2023                          encryption subkey ;-). */
2024       else
2025         nbits = primary_keysize;
2026       autocomp = 1;
2027       goto leave;
2028     }
2029
2030   /* Deviations from the standard values.  */
2031   switch(algo)
2032     {
2033     case PUBKEY_ALGO_DSA:
2034       min = opt.expert? 768 : 1024;
2035       def=2048;
2036       max=3072;
2037       break;
2038
2039     case PUBKEY_ALGO_ECDSA:
2040     case PUBKEY_ALGO_ECDH:
2041       min=256;
2042       def=256;
2043       max=521;
2044       break;
2045
2046     case PUBKEY_ALGO_EDDSA:
2047       min=255;
2048       def=255;
2049       max=441;
2050       break;
2051     }
2052
2053   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
2054              openpgp_pk_algo_name (algo), min, max);
2055
2056   for (;;)
2057     {
2058       char *prompt, *answer;
2059
2060       if (for_subkey)
2061         prompt = xasprintf (_("What keysize do you want "
2062                               "for the subkey? (%u) "), def);
2063       else
2064         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
2065       answer = cpr_get ("keygen.size", prompt);
2066       cpr_kill_prompt ();
2067       nbits = *answer? atoi (answer): def;
2068       xfree(prompt);
2069       xfree(answer);
2070
2071       if(nbits<min || nbits>max)
2072         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
2073                    openpgp_pk_algo_name (algo), min, max);
2074       else
2075         break;
2076     }
2077
2078   tty_printf (_("Requested keysize is %u bits\n"), nbits);
2079
2080  leave:
2081   if (algo == PUBKEY_ALGO_DSA && (nbits % 64))
2082     {
2083       nbits = ((nbits + 63) / 64) * 64;
2084       if (!autocomp)
2085         tty_printf (_("rounded up to %u bits\n"), nbits);
2086     }
2087   else if (algo == PUBKEY_ALGO_EDDSA)
2088     {
2089       if (nbits != 255 && nbits != 441)
2090         {
2091           if (nbits < 256)
2092             nbits = 255;
2093           else
2094             nbits = 441;
2095           if (!autocomp)
2096             tty_printf (_("rounded to %u bits\n"), nbits);
2097         }
2098     }
2099   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
2100     {
2101       if (nbits != 256 && nbits != 384 && nbits != 521)
2102         {
2103           if (nbits < 256)
2104             nbits = 256;
2105           else if (nbits < 384)
2106             nbits = 384;
2107           else
2108             nbits = 521;
2109           if (!autocomp)
2110             tty_printf (_("rounded to %u bits\n"), nbits);
2111         }
2112     }
2113   else if ((nbits % 32))
2114     {
2115       nbits = ((nbits + 31) / 32) * 32;
2116       if (!autocomp)
2117         tty_printf (_("rounded up to %u bits\n"), nbits );
2118     }
2119
2120   return nbits;
2121 }
2122
2123
2124 /* Ask for the curve.  ALGO is the selected algorithm which this
2125    function may adjust.  Returns a malloced string with the name of
2126    the curve.  BOTH tells that gpg creates a primary and subkey. */
2127 static char *
2128 ask_curve (int *algo, int *subkey_algo)
2129 {
2130   struct {
2131     const char *name;
2132     int available;
2133     int expert_only;
2134     int fix_curve;
2135     const char *pretty_name;
2136   } curves[] = {
2137 #if GPG_USE_EDDSA
2138     { "Curve25519",      0, 0, 1, "Curve 25519" },
2139 #endif
2140 #if GPG_USE_ECDSA || GPG_USE_ECDH
2141     { "NIST P-256",      0, 1, 0, },
2142     { "NIST P-384",      0, 0, 0, },
2143     { "NIST P-521",      0, 1, 0, },
2144     { "brainpoolP256r1", 0, 1, 0, "Brainpool P-256" },
2145     { "brainpoolP384r1", 0, 1, 0, "Brainpool P-384" },
2146     { "brainpoolP512r1", 0, 1, 0, "Brainpool P-512" },
2147     { "secp256k1",       0, 1, 0  },
2148 #endif
2149   };
2150   int idx;
2151   char *answer;
2152   char *result = NULL;
2153   gcry_sexp_t keyparms;
2154
2155   tty_printf (_("Please select which elliptic curve you want:\n"));
2156
2157  again:
2158   keyparms = NULL;
2159   for (idx=0; idx < DIM(curves); idx++)
2160     {
2161       int rc;
2162
2163       curves[idx].available = 0;
2164       if (!opt.expert && curves[idx].expert_only)
2165         continue;
2166
2167       /* FIXME: The strcmp below is a temporary hack during
2168          development.  It shall be removed as soon as we have proper
2169          Curve25519 support in Libgcrypt.  */
2170       gcry_sexp_release (keyparms);
2171       rc = gcry_sexp_build (&keyparms, NULL,
2172                             "(public-key(ecc(curve %s)))",
2173                             (!strcmp (curves[idx].name, "Curve25519")
2174                              ? "Ed25519" : curves[idx].name));
2175       if (rc)
2176         continue;
2177       if (!gcry_pk_get_curve (keyparms, 0, NULL))
2178         continue;
2179       if (subkey_algo && curves[idx].fix_curve)
2180         {
2181           /* Both Curve 25519 keys are to be created.  Check that
2182              Libgcrypt also supports the real Curve25519.  */
2183           gcry_sexp_release (keyparms);
2184           rc = gcry_sexp_build (&keyparms, NULL,
2185                                 "(public-key(ecc(curve %s)))",
2186                                  curves[idx].name);
2187           if (rc)
2188             continue;
2189           if (!gcry_pk_get_curve (keyparms, 0, NULL))
2190             continue;
2191         }
2192
2193       curves[idx].available = 1;
2194       tty_printf ("   (%d) %s\n", idx + 1,
2195                   curves[idx].pretty_name?
2196                   curves[idx].pretty_name:curves[idx].name);
2197     }
2198   gcry_sexp_release (keyparms);
2199
2200
2201   for (;;)
2202     {
2203       answer = cpr_get ("keygen.curve", _("Your selection? "));
2204       cpr_kill_prompt ();
2205       idx = *answer? atoi (answer) : 1;
2206       if (*answer && !idx)
2207         {
2208           /* See whether the user entered the name of the curve.  */
2209           for (idx=0; idx < DIM(curves); idx++)
2210             {
2211               if (!opt.expert && curves[idx].expert_only)
2212                 continue;
2213               if (!stricmp (curves[idx].name, answer)
2214                   || (curves[idx].pretty_name
2215                       && !stricmp (curves[idx].pretty_name, answer)))
2216                 break;
2217             }
2218           if (idx == DIM(curves))
2219             idx = -1;
2220         }
2221       else
2222         idx--;
2223       xfree(answer);
2224       answer = NULL;
2225       if (idx < 0 || idx >= DIM (curves) || !curves[idx].available)
2226         tty_printf (_("Invalid selection.\n"));
2227       else
2228         {
2229           if (curves[idx].fix_curve)
2230             {
2231               log_info ("WARNING: Curve25519 is not yet part of the"
2232                         " OpenPGP standard.\n");
2233
2234               if (!cpr_get_answer_is_yes("experimental_curve.override",
2235                                          "Use this curve anyway? (y/N) ")  )
2236                 goto again;
2237             }
2238
2239           /* If the user selected a signing algorithm and Curve25519
2240              we need to update the algo and and the curve name.  */
2241           if ((*algo == PUBKEY_ALGO_ECDSA || *algo == PUBKEY_ALGO_EDDSA)
2242               && curves[idx].fix_curve)
2243             {
2244               if (subkey_algo && *subkey_algo == PUBKEY_ALGO_ECDSA)
2245                 *subkey_algo = PUBKEY_ALGO_EDDSA;
2246               *algo = PUBKEY_ALGO_EDDSA;
2247               result = xstrdup ("Ed25519");
2248             }
2249           else
2250             result = xstrdup (curves[idx].name);
2251           break;
2252         }
2253     }
2254
2255   if (!result)
2256     result = xstrdup (curves[0].name);
2257
2258   return result;
2259 }
2260
2261
2262 /****************
2263  * Parse an expire string and return its value in seconds.
2264  * Returns (u32)-1 on error.
2265  * This isn't perfect since scan_isodatestr returns unix time, and
2266  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
2267  * Because of this, we only permit setting expirations up to 2106, but
2268  * OpenPGP could theoretically allow up to 2242.  I think we'll all
2269  * just cope for the next few years until we get a 64-bit time_t or
2270  * similar.
2271  */
2272 u32
2273 parse_expire_string( const char *string )
2274 {
2275   int mult;
2276   u32 seconds;
2277   u32 abs_date = 0;
2278   u32 curtime = make_timestamp ();
2279   time_t tt;
2280
2281   if (!*string)
2282     seconds = 0;
2283   else if (!strncmp (string, "seconds=", 8))
2284     seconds = atoi (string+8);
2285   else if ((abs_date = scan_isodatestr(string))
2286            && (abs_date+86400/2) > curtime)
2287     seconds = (abs_date+86400/2) - curtime;
2288   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
2289     seconds = (u32)tt - curtime;
2290   else if ((mult = check_valid_days (string)))
2291     seconds = atoi (string) * 86400L * mult;
2292   else
2293     seconds = (u32)(-1);
2294
2295   return seconds;
2296 }
2297
2298 /* Parsean Creation-Date string which is either "1986-04-26" or
2299    "19860426T042640".  Returns 0 on error. */
2300 static u32
2301 parse_creation_string (const char *string)
2302 {
2303   u32 seconds;
2304
2305   if (!*string)
2306     seconds = 0;
2307   else if ( !strncmp (string, "seconds=", 8) )
2308     seconds = atoi (string+8);
2309   else if ( !(seconds = scan_isodatestr (string)))
2310     {
2311       time_t tmp = isotime2epoch (string);
2312       seconds = (tmp == (time_t)(-1))? 0 : tmp;
2313     }
2314   return seconds;
2315 }
2316
2317
2318 /* object == 0 for a key, and 1 for a sig */
2319 u32
2320 ask_expire_interval(int object,const char *def_expire)
2321 {
2322     u32 interval;
2323     char *answer;
2324
2325     switch(object)
2326       {
2327       case 0:
2328         if(def_expire)
2329           BUG();
2330         tty_printf(_("Please specify how long the key should be valid.\n"
2331                      "         0 = key does not expire\n"
2332                      "      <n>  = key expires in n days\n"
2333                      "      <n>w = key expires in n weeks\n"
2334                      "      <n>m = key expires in n months\n"
2335                      "      <n>y = key expires in n years\n"));
2336         break;
2337
2338       case 1:
2339         if(!def_expire)
2340           BUG();
2341         tty_printf(_("Please specify how long the signature should be valid.\n"
2342                      "         0 = signature does not expire\n"
2343                      "      <n>  = signature expires in n days\n"
2344                      "      <n>w = signature expires in n weeks\n"
2345                      "      <n>m = signature expires in n months\n"
2346                      "      <n>y = signature expires in n years\n"));
2347         break;
2348
2349       default:
2350         BUG();
2351       }
2352
2353     /* Note: The elgamal subkey for DSA has no expiration date because
2354      * it must be signed with the DSA key and this one has the expiration
2355      * date */
2356
2357     answer = NULL;
2358     for(;;)
2359       {
2360         u32 curtime;
2361
2362         xfree(answer);
2363         if(object==0)
2364           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
2365         else
2366           {
2367             char *prompt;
2368
2369 #define PROMPTSTRING _("Signature is valid for? (%s) ")
2370             /* This will actually end up larger than necessary because
2371                of the 2 bytes for '%s' */
2372             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
2373             sprintf(prompt,PROMPTSTRING,def_expire);
2374 #undef PROMPTSTRING
2375
2376             answer = cpr_get("siggen.valid",prompt);
2377             xfree(prompt);
2378
2379             if(*answer=='\0')
2380               answer=xstrdup(def_expire);
2381           }
2382         cpr_kill_prompt();
2383         trim_spaces(answer);
2384         curtime = make_timestamp ();
2385         interval = parse_expire_string( answer );
2386         if( interval == (u32)-1 )
2387           {
2388             tty_printf(_("invalid value\n"));
2389             continue;
2390           }
2391
2392         if( !interval )
2393           {
2394             tty_printf((object==0)
2395                        ? _("Key does not expire at all\n")
2396                        : _("Signature does not expire at all\n"));
2397           }
2398         else
2399           {
2400             tty_printf(object==0
2401                        ? _("Key expires at %s\n")
2402                        : _("Signature expires at %s\n"),
2403                        asctimestamp((ulong)(curtime + interval) ) );
2404 #if SIZEOF_TIME_T <= 4 && !defined (HAVE_UNSIGNED_TIME_T)
2405             if ( (time_t)((ulong)(curtime+interval)) < 0 )
2406               tty_printf (_("Your system can't display dates beyond 2038.\n"
2407                             "However, it will be correctly handled up to"
2408                             " 2106.\n"));
2409             else
2410 #endif /*SIZEOF_TIME_T*/
2411               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
2412                 {
2413                   tty_printf (_("invalid value\n"));
2414                   continue;
2415                 }
2416           }
2417
2418         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
2419                                                    _("Is this correct? (y/N) ")) )
2420           break;
2421       }
2422
2423     xfree(answer);
2424     return interval;
2425 }
2426
2427 u32
2428 ask_expiredate()
2429 {
2430     u32 x = ask_expire_interval(0,NULL);
2431     return x? make_timestamp() + x : 0;
2432 }
2433
2434
2435
2436 static PKT_user_id *
2437 uid_from_string (const char *string)
2438 {
2439   size_t n;
2440   PKT_user_id *uid;
2441
2442   n = strlen (string);
2443   uid = xmalloc_clear (sizeof *uid + n);
2444   uid->len = n;
2445   strcpy (uid->name, string);
2446   uid->ref = 1;
2447   return uid;
2448 }
2449
2450
2451 /* Return true if the user id UID already exists in the keyblock.  */
2452 static int
2453 uid_already_in_keyblock (kbnode_t keyblock, const char *uid)
2454 {
2455   PKT_user_id *uidpkt = uid_from_string (uid);
2456   kbnode_t node;
2457   int result = 0;
2458
2459   for (node=keyblock; node && !result; node=node->next)
2460     if (!is_deleted_kbnode (node)
2461         && node->pkt->pkttype == PKT_USER_ID
2462         && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2463       result = 1;
2464   free_user_id (uidpkt);
2465   return result;
2466 }
2467
2468
2469 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
2470    printed for use during a new key creation.  If KEYBLOCK is not NULL
2471    the function prevents the creation of an already existing user
2472    ID.  IF FULL is not set some prompts are not shown.  */
2473 static char *
2474 ask_user_id (int mode, int full, KBNODE keyblock)
2475 {
2476     char *answer;
2477     char *aname, *acomment, *amail, *uid;
2478
2479     if ( !mode )
2480       {
2481         /* TRANSLATORS: This is the new string telling the user what
2482            gpg is now going to do (i.e. ask for the parts of the user
2483            ID).  Note that if you do not translate this string, a
2484            different string will be used, which might still have
2485            a correct translation.  */
2486         const char *s1 =
2487           N_("\n"
2488              "GnuPG needs to construct a user ID to identify your key.\n"
2489              "\n");
2490         const char *s2 = _(s1);
2491
2492         if (!strcmp (s1, s2))
2493           {
2494             /* There is no translation for the string thus we to use
2495                the old info text.  gettext has no way to tell whether
2496                a translation is actually available, thus we need to
2497                to compare again. */
2498             /* TRANSLATORS: This string is in general not anymore used
2499                but you should keep your existing translation.  In case
2500                the new string is not translated this old string will
2501                be used. */
2502             const char *s3 = N_("\n"
2503 "You need a user ID to identify your key; "
2504                                         "the software constructs the user ID\n"
2505 "from the Real Name, Comment and Email Address in this form:\n"
2506 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
2507             const char *s4 = _(s3);
2508             if (strcmp (s3, s4))
2509               s2 = s3; /* A translation exists - use it. */
2510           }
2511         tty_printf ("%s", s2) ;
2512       }
2513     uid = aname = acomment = amail = NULL;
2514     for(;;) {
2515         char *p;
2516         int fail=0;
2517
2518         if( !aname ) {
2519             for(;;) {
2520                 xfree(aname);
2521                 aname = cpr_get("keygen.name",_("Real name: "));
2522                 trim_spaces(aname);
2523                 cpr_kill_prompt();
2524
2525                 if( opt.allow_freeform_uid )
2526                     break;
2527
2528                 if( strpbrk( aname, "<>" ) )
2529                   {
2530                     tty_printf(_("Invalid character in name\n"));
2531                     tty_printf(_("The characters '%s' and '%s' may not "
2532                                  "appear in name\n"), "<", ">");
2533                   }
2534                 else if( digitp(aname) )
2535                     tty_printf(_("Name may not start with a digit\n"));
2536                 else if (*aname && strlen (aname) < 5)
2537                   {
2538                     tty_printf(_("Name must be at least 5 characters long\n"));
2539                     /* However, we allow an empty name.  */
2540                   }
2541                 else
2542                     break;
2543             }
2544         }
2545         if( !amail ) {
2546             for(;;) {
2547                 xfree(amail);
2548                 amail = cpr_get("keygen.email",_("Email address: "));
2549                 trim_spaces(amail);
2550                 cpr_kill_prompt();
2551                 if( !*amail || opt.allow_freeform_uid )
2552                     break;   /* no email address is okay */
2553                 else if ( !is_valid_mailbox (amail) )
2554                     tty_printf(_("Not a valid email address\n"));
2555                 else
2556                     break;
2557             }
2558         }
2559         if (!acomment) {
2560           if (full) {
2561             for(;;) {
2562                 xfree(acomment);
2563                 acomment = cpr_get("keygen.comment",_("Comment: "));
2564                 trim_spaces(acomment);
2565                 cpr_kill_prompt();
2566                 if( !*acomment )
2567                     break;   /* no comment is okay */
2568                 else if( strpbrk( acomment, "()" ) )
2569                     tty_printf(_("Invalid character in comment\n"));
2570                 else
2571                     break;
2572             }
2573           }
2574           else {
2575             xfree (acomment);
2576             acomment = xstrdup ("");
2577           }
2578         }
2579
2580
2581         xfree(uid);
2582         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
2583         if (!*aname && *amail && !*acomment && !random_is_faked ())
2584           { /* Empty name and comment but with mail address.  Use
2585                simplified form with only the non-angle-bracketed mail
2586                address.  */
2587             p = stpcpy (p, amail);
2588           }
2589         else
2590           {
2591             p = stpcpy (p, aname );
2592             if (*acomment)
2593               p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
2594             if (*amail)
2595               p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
2596           }
2597
2598         /* Append a warning if the RNG is switched into fake mode.  */
2599         if ( random_is_faked ()  )
2600           strcpy(p, " (insecure!)" );
2601
2602         /* print a note in case that UTF8 mapping has to be done */
2603         for(p=uid; *p; p++ ) {
2604             if( *p & 0x80 ) {
2605                 tty_printf(_("You are using the '%s' character set.\n"),
2606                            get_native_charset() );
2607                 break;
2608             }
2609         }
2610
2611         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2612
2613         if( !*amail && !opt.allow_freeform_uid
2614             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2615             fail = 1;
2616             tty_printf(_("Please don't put the email address "
2617                          "into the real name or the comment\n") );
2618         }
2619
2620         if (!fail && keyblock)
2621           {
2622             if (uid_already_in_keyblock (keyblock, uid))
2623               {
2624                 tty_printf (_("Such a user ID already exists on this key!\n"));
2625                 fail = 1;
2626               }
2627           }
2628
2629         for(;;) {
2630             /* TRANSLATORS: These are the allowed answers in
2631                lower and uppercase.  Below you will find the matching
2632                string which should be translated accordingly and the
2633                letter changed to match the one in the answer string.
2634
2635                  n = Change name
2636                  c = Change comment
2637                  e = Change email
2638                  o = Okay (ready, continue)
2639                  q = Quit
2640              */
2641             const char *ansstr = _("NnCcEeOoQq");
2642
2643             if( strlen(ansstr) != 10 )
2644                 BUG();
2645             if( cpr_enabled() ) {
2646                 answer = xstrdup (ansstr + (fail?8:6));
2647                 answer[1] = 0;
2648             }
2649             else if (full) {
2650                 answer = cpr_get("keygen.userid.cmd", fail?
2651                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2652                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2653                 cpr_kill_prompt();
2654             }
2655             else {
2656                 answer = cpr_get("keygen.userid.cmd", fail?
2657                   _("Change (N)ame, (E)mail, or (Q)uit? ") :
2658                   _("Change (N)ame, (E)mail, or (O)kay/(Q)uit? "));
2659                 cpr_kill_prompt();
2660             }
2661             if( strlen(answer) > 1 )
2662                 ;
2663             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2664                 xfree(aname); aname = NULL;
2665                 break;
2666             }
2667             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2668                 xfree(acomment); acomment = NULL;
2669                 break;
2670             }
2671             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2672                 xfree(amail); amail = NULL;
2673                 break;
2674             }
2675             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2676                 if( fail ) {
2677                     tty_printf(_("Please correct the error first\n"));
2678                 }
2679                 else {
2680                     xfree(aname); aname = NULL;
2681                     xfree(acomment); acomment = NULL;
2682                     xfree(amail); amail = NULL;
2683                     break;
2684                 }
2685             }
2686             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2687                 xfree(aname); aname = NULL;
2688                 xfree(acomment); acomment = NULL;
2689                 xfree(amail); amail = NULL;
2690                 xfree(uid); uid = NULL;
2691                 break;
2692             }
2693             xfree(answer);
2694         }
2695         xfree(answer);
2696         if (!amail && !acomment)
2697             break;
2698         xfree(uid); uid = NULL;
2699     }
2700     if( uid ) {
2701         char *p = native_to_utf8( uid );
2702         xfree( uid );
2703         uid = p;
2704     }
2705     return uid;
2706 }
2707
2708
2709 /* Basic key generation.  Here we divert to the actual generation
2710    routines based on the requested algorithm.  */
2711 static int
2712 do_create (int algo, unsigned int nbits, const char *curve, KBNODE pub_root,
2713            u32 timestamp, u32 expiredate, int is_subkey,
2714            int keygen_flags, const char *passphrase, char **cache_nonce_addr)
2715 {
2716   gpg_error_t err;
2717
2718   /* Fixme: The entropy collecting message should be moved to a
2719      libgcrypt progress handler.  */
2720   if (!opt.batch)
2721     tty_printf (_(
2722 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2723 "some other action (type on the keyboard, move the mouse, utilize the\n"
2724 "disks) during the prime generation; this gives the random number\n"
2725 "generator a better chance to gain enough entropy.\n") );
2726
2727   if (algo == PUBKEY_ALGO_ELGAMAL_E)
2728     err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2729                    keygen_flags, passphrase, cache_nonce_addr);
2730   else if (algo == PUBKEY_ALGO_DSA)
2731     err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
2732                    keygen_flags, passphrase, cache_nonce_addr);
2733   else if (algo == PUBKEY_ALGO_ECDSA
2734            || algo == PUBKEY_ALGO_EDDSA
2735            || algo == PUBKEY_ALGO_ECDH)
2736     err = gen_ecc (algo, curve, pub_root, timestamp, expiredate, is_subkey,
2737                    keygen_flags, passphrase, cache_nonce_addr);
2738   else if (algo == PUBKEY_ALGO_RSA)
2739     err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2740                    keygen_flags, passphrase, cache_nonce_addr);
2741   else
2742     BUG();
2743
2744   return err;
2745 }
2746
2747
2748 /* Generate a new user id packet or return NULL if canceled.  If
2749    KEYBLOCK is not NULL the function prevents the creation of an
2750    already existing user ID.  If UIDSTR is not NULL the user is not
2751    asked but UIDSTR is used to create the user id packet; if the user
2752    id already exists NULL is returned.  UIDSTR is expected to be utf-8
2753    encoded and should have already been checked for a valid length
2754    etc.  */
2755 PKT_user_id *
2756 generate_user_id (KBNODE keyblock, const char *uidstr)
2757 {
2758   PKT_user_id *uid;
2759   char *p;
2760
2761   if (uidstr)
2762     {
2763       if (uid_already_in_keyblock (keyblock, uidstr))
2764         return NULL;  /* Already exists.  */
2765       uid = uid_from_string (uidstr);
2766     }
2767   else
2768     {
2769       p = ask_user_id (1, 1, keyblock);
2770       if (!p)
2771         return NULL;  /* Canceled. */
2772       uid = uid_from_string (p);
2773       xfree (p);
2774     }
2775   return uid;
2776 }
2777
2778
2779 /* Append R to the linked list PARA.  */
2780 static void
2781 append_to_parameter (struct para_data_s *para, struct para_data_s *r)
2782 {
2783   assert (para);
2784   while (para->next)
2785     para = para->next;
2786   para->next = r;
2787 }
2788
2789 /* Release the parameter list R.  */
2790 static void
2791 release_parameter_list (struct para_data_s *r)
2792 {
2793   struct para_data_s *r2;
2794
2795   for (; r ; r = r2)
2796     {
2797       r2 = r->next;
2798       if (r->key == pPASSPHRASE && *r->u.value)
2799         wipememory (r->u.value, strlen (r->u.value));
2800       xfree (r);
2801     }
2802 }
2803
2804 static struct para_data_s *
2805 get_parameter( struct para_data_s *para, enum para_name key )
2806 {
2807     struct para_data_s *r;
2808
2809     for( r = para; r && r->key != key; r = r->next )
2810         ;
2811     return r;
2812 }
2813
2814 static const char *
2815 get_parameter_value( struct para_data_s *para, enum para_name key )
2816 {
2817     struct para_data_s *r = get_parameter( para, key );
2818     return (r && *r->u.value)? r->u.value : NULL;
2819 }
2820
2821
2822 /* This is similar to get_parameter_value but also returns the empty
2823    string.  This is required so that quick_generate_keypair can use an
2824    empty Passphrase to specify no-protection.  */
2825 static const char *
2826 get_parameter_passphrase (struct para_data_s *para)
2827 {
2828   struct para_data_s *r = get_parameter (para, pPASSPHRASE);
2829   return r ? r->u.value : NULL;
2830 }
2831
2832
2833 static int
2834 get_parameter_algo( struct para_data_s *para, enum para_name key,
2835                     int *r_default)
2836 {
2837   int i;
2838   struct para_data_s *r = get_parameter( para, key );
2839
2840   if (r_default)
2841     *r_default = 0;
2842
2843   if (!r)
2844     return -1;
2845
2846   /* Note that we need to handle the ECC algorithms specified as
2847      strings directly because Libgcrypt folds them all to ECC.  */
2848   if (!ascii_strcasecmp (r->u.value, "default"))
2849     {
2850       /* Note: If you change this default algo, remember to change it
2851          also in gpg.c:gpgconf_list.  */
2852       i = DEFAULT_STD_ALGO;
2853       if (r_default)
2854         *r_default = 1;
2855     }
2856   else if (digitp (r->u.value))
2857     i = atoi( r->u.value );
2858   else if (!strcmp (r->u.value, "ELG-E")
2859            || !strcmp (r->u.value, "ELG"))
2860     i = PUBKEY_ALGO_ELGAMAL_E;
2861   else if (!ascii_strcasecmp (r->u.value, "EdDSA"))
2862     i = PUBKEY_ALGO_EDDSA;
2863   else if (!ascii_strcasecmp (r->u.value, "ECDSA"))
2864     i = PUBKEY_ALGO_ECDSA;
2865   else if (!ascii_strcasecmp (r->u.value, "ECDH"))
2866     i = PUBKEY_ALGO_ECDH;
2867   else
2868     i = map_pk_gcry_to_openpgp (gcry_pk_map_name (r->u.value));
2869
2870   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2871     i = 0; /* we don't want to allow generation of these algorithms */
2872   return i;
2873 }
2874
2875 /*
2876  * Parse the usage parameter and set the keyflags.  Returns -1 on
2877  * error, 0 for no usage given or 1 for usage available.
2878  */
2879 static int
2880 parse_parameter_usage (const char *fname,
2881                        struct para_data_s *para, enum para_name key)
2882 {
2883     struct para_data_s *r = get_parameter( para, key );
2884     char *p, *pn;
2885     unsigned int use;
2886
2887     if( !r )
2888         return 0; /* none (this is an optional parameter)*/
2889
2890     use = 0;
2891     pn = r->u.value;
2892     while ( (p = strsep (&pn, " \t,")) ) {
2893         if ( !*p)
2894             ;
2895         else if ( !ascii_strcasecmp (p, "sign") )
2896             use |= PUBKEY_USAGE_SIG;
2897         else if ( !ascii_strcasecmp (p, "encrypt") )
2898             use |= PUBKEY_USAGE_ENC;
2899         else if ( !ascii_strcasecmp (p, "auth") )
2900             use |= PUBKEY_USAGE_AUTH;
2901         else {
2902             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2903             return -1; /* error */
2904         }
2905     }
2906     r->u.usage = use;
2907     return 1;
2908 }
2909
2910 static int
2911 parse_revocation_key (const char *fname,
2912                       struct para_data_s *para, enum para_name key)
2913 {
2914   struct para_data_s *r = get_parameter( para, key );
2915   struct revocation_key revkey;
2916   char *pn;
2917   int i;
2918
2919   if( !r )
2920     return 0; /* none (this is an optional parameter) */
2921
2922   pn = r->u.value;
2923
2924   revkey.class=0x80;
2925   revkey.algid=atoi(pn);
2926   if(!revkey.algid)
2927     goto fail;
2928
2929   /* Skip to the fpr */
2930   while(*pn && *pn!=':')
2931     pn++;
2932
2933   if(*pn!=':')
2934     goto fail;
2935
2936   pn++;
2937
2938   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2939     {
2940       int c=hextobyte(pn);
2941       if(c==-1)
2942         goto fail;
2943
2944       revkey.fpr[i]=c;
2945     }
2946
2947   /* skip to the tag */
2948   while(*pn && *pn!='s' && *pn!='S')
2949     pn++;
2950
2951   if(ascii_strcasecmp(pn,"sensitive")==0)
2952     revkey.class|=0x40;
2953
2954   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2955
2956   return 0;
2957
2958   fail:
2959   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2960   return -1; /* error */
2961 }
2962
2963
2964 static u32
2965 get_parameter_u32( struct para_data_s *para, enum para_name key )
2966 {
2967   struct para_data_s *r = get_parameter( para, key );
2968
2969   if( !r )
2970     return 0;
2971   if( r->key == pKEYCREATIONDATE )
2972     return r->u.creation;
2973   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2974     return r->u.expire;
2975   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2976     return r->u.usage;
2977
2978   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2979 }
2980
2981 static unsigned int
2982 get_parameter_uint( struct para_data_s *para, enum para_name key )
2983 {
2984     return get_parameter_u32( para, key );
2985 }
2986
2987 static struct revocation_key *
2988 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2989 {
2990     struct para_data_s *r = get_parameter( para, key );
2991     return r? &r->u.revkey : NULL;
2992 }
2993
2994 static int
2995 proc_parameter_file (ctrl_t ctrl, struct para_data_s *para, const char *fname,
2996                      struct output_control_s *outctrl, int card )
2997 {
2998   struct para_data_s *r;
2999   const char *s1, *s2, *s3;
3000   size_t n;
3001   char *p;
3002   int is_default = 0;
3003   int have_user_id = 0;
3004   int err, algo;
3005
3006   /* Check that we have all required parameters. */
3007   r = get_parameter( para, pKEYTYPE );
3008   if(r)
3009     {
3010       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
3011       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
3012         {
3013           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
3014           return -1;
3015         }
3016     }
3017   else
3018     {
3019       log_error ("%s: no Key-Type specified\n",fname);
3020       return -1;
3021     }
3022
3023   err = parse_parameter_usage (fname, para, pKEYUSAGE);
3024   if (!err)
3025     {
3026       /* Default to algo capabilities if key-usage is not provided and
3027          no default algorithm has been requested.  */
3028       r = xmalloc_clear(sizeof(*r));
3029       r->key = pKEYUSAGE;
3030       r->u.usage = (is_default
3031                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
3032                     : openpgp_pk_algo_usage(algo));
3033       append_to_parameter (para, r);
3034     }
3035   else if (err == -1)
3036     return -1;
3037   else
3038     {
3039       r = get_parameter (para, pKEYUSAGE);
3040       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3041         {
3042           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
3043                      fname, r->lnr, algo);
3044           return -1;
3045         }
3046     }
3047
3048   is_default = 0;
3049   r = get_parameter( para, pSUBKEYTYPE );
3050   if(r)
3051     {
3052       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
3053       if (openpgp_pk_test_algo (algo))
3054         {
3055           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
3056           return -1;
3057         }
3058
3059       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
3060       if (!err)
3061         {
3062           /* Default to algo capabilities if subkey-usage is not
3063              provided */
3064           r = xmalloc_clear (sizeof(*r));
3065           r->key = pSUBKEYUSAGE;
3066           r->u.usage = (is_default
3067                         ? PUBKEY_USAGE_ENC
3068                         : openpgp_pk_algo_usage (algo));
3069           append_to_parameter (para, r);
3070         }
3071       else if (err == -1)
3072         return -1;
3073       else
3074         {
3075           r = get_parameter (para, pSUBKEYUSAGE);
3076           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
3077             {
3078               log_error ("%s:%d: specified Subkey-Usage not allowed"
3079                          " for algo %d\n", fname, r->lnr, algo);
3080               return -1;
3081             }
3082         }
3083     }
3084
3085
3086   if( get_parameter_value( para, pUSERID ) )
3087     have_user_id=1;
3088   else
3089     {
3090       /* create the formatted user ID */
3091       s1 = get_parameter_value( para, pNAMEREAL );
3092       s2 = get_parameter_value( para, pNAMECOMMENT );
3093       s3 = get_parameter_value( para, pNAMEEMAIL );
3094       if( s1 || s2 || s3 )
3095         {
3096           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
3097           r = xmalloc_clear( sizeof *r + n + 20 );
3098           r->key = pUSERID;
3099           p = r->u.value;
3100           if( s1 )
3101             p = stpcpy(p, s1 );
3102           if( s2 )
3103             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
3104           if( s3 )
3105             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
3106           append_to_parameter (para, r);
3107           have_user_id=1;
3108         }
3109     }
3110
3111   if(!have_user_id)
3112     {
3113       log_error("%s: no User-ID specified\n",fname);
3114       return -1;
3115     }
3116
3117   /* Set preferences, if any. */
3118   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
3119
3120   /* Set keyserver, if any. */
3121   s1=get_parameter_value( para, pKEYSERVER );
3122   if(s1)
3123     {
3124       struct keyserver_spec *spec;
3125
3126       spec = parse_keyserver_uri (s1, 1);
3127       if(spec)
3128         {
3129           free_keyserver_spec(spec);
3130           opt.def_keyserver_url=s1;
3131         }
3132       else
3133         {
3134           r = get_parameter (para, pKEYSERVER);
3135           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
3136           return -1;
3137         }
3138     }
3139
3140   /* Set revoker, if any. */
3141   if (parse_revocation_key (fname, para, pREVOKER))
3142     return -1;
3143
3144
3145   /* Make KEYCREATIONDATE from Creation-Date.  */
3146   r = get_parameter (para, pCREATIONDATE);
3147   if (r && *r->u.value)
3148     {
3149       u32 seconds;
3150
3151       seconds = parse_creation_string (r->u.value);
3152       if (!seconds)
3153         {
3154           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
3155           return -1;
3156         }
3157       r->u.creation = seconds;
3158       r->key = pKEYCREATIONDATE;  /* Change that entry. */
3159     }
3160
3161   /* Make KEYEXPIRE from Expire-Date.  */
3162   r = get_parameter( para, pEXPIREDATE );
3163   if( r && *r->u.value )
3164     {
3165       u32 seconds;
3166
3167       seconds = parse_expire_string( r->u.value );
3168       if( seconds == (u32)-1 )
3169         {
3170           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
3171           return -1;
3172         }
3173       r->u.expire = seconds;
3174       r->key = pKEYEXPIRE;  /* change hat entry */
3175       /* also set it for the subkey */
3176       r = xmalloc_clear( sizeof *r + 20 );
3177       r->key = pSUBKEYEXPIRE;
3178       r->u.expire = seconds;
3179       append_to_parameter (para, r);
3180     }
3181
3182   do_generate_keypair (ctrl, para, outctrl, card );
3183   return 0;
3184 }
3185
3186
3187 /****************
3188  * Kludge to allow non interactive key generation controlled
3189  * by a parameter file.
3190  * Note, that string parameters are expected to be in UTF-8
3191  */
3192 static void
3193 read_parameter_file (ctrl_t ctrl, const char *fname )
3194 {
3195     static struct { const char *name;
3196                     enum para_name key;
3197     } keywords[] = {
3198         { "Key-Type",       pKEYTYPE},
3199         { "Key-Length",     pKEYLENGTH },
3200         { "Key-Curve",      pKEYCURVE },
3201         { "Key-Usage",      pKEYUSAGE },
3202         { "Subkey-Type",    pSUBKEYTYPE },
3203         { "Subkey-Length",  pSUBKEYLENGTH },
3204         { "Subkey-Curve",   pSUBKEYCURVE },
3205         { "Subkey-Usage",   pSUBKEYUSAGE },
3206         { "Name-Real",      pNAMEREAL },
3207         { "Name-Email",     pNAMEEMAIL },
3208         { "Name-Comment",   pNAMECOMMENT },
3209         { "Expire-Date",    pEXPIREDATE },
3210         { "Creation-Date",  pCREATIONDATE },
3211         { "Passphrase",     pPASSPHRASE },
3212         { "Preferences",    pPREFERENCES },
3213         { "Revoker",        pREVOKER },
3214         { "Handle",         pHANDLE },
3215         { "Keyserver",      pKEYSERVER },
3216         { NULL, 0 }
3217     };
3218     IOBUF fp;
3219     byte *line;
3220     unsigned int maxlen, nline;
3221     char *p;
3222     int lnr;
3223     const char *err = NULL;
3224     struct para_data_s *para, *r;
3225     int i;
3226     struct output_control_s outctrl;
3227
3228     memset( &outctrl, 0, sizeof( outctrl ) );
3229     outctrl.pub.afx = new_armor_context ();
3230
3231     if( !fname || !*fname)
3232       fname = "-";
3233
3234     fp = iobuf_open (fname);
3235     if (fp && is_secured_file (iobuf_get_fd (fp)))
3236       {
3237         iobuf_close (fp);
3238         fp = NULL;
3239         gpg_err_set_errno (EPERM);
3240       }
3241     if (!fp) {
3242       log_error (_("can't open '%s': %s\n"), fname, strerror(errno) );
3243       return;
3244     }
3245     iobuf_ioctl (fp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
3246
3247     lnr = 0;
3248     err = NULL;
3249     para = NULL;
3250     maxlen = 1024;
3251     line = NULL;
3252     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
3253         char *keyword, *value;
3254
3255         lnr++;
3256         if( !maxlen ) {
3257             err = "line too long";
3258             break;
3259         }
3260         for( p = line; isspace(*(byte*)p); p++ )
3261             ;
3262         if( !*p || *p == '#' )
3263             continue;
3264         keyword = p;
3265         if( *keyword == '%' ) {
3266             for( ; !isspace(*(byte*)p); p++ )
3267                 ;
3268             if( *p )
3269                 *p++ = 0;
3270             for( ; isspace(*(byte*)p); p++ )
3271                 ;
3272             value = p;
3273             trim_trailing_ws( value, strlen(value) );
3274             if( !ascii_strcasecmp( keyword, "%echo" ) )
3275                 log_info("%s\n", value );
3276             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
3277                 outctrl.dryrun = 1;
3278             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
3279               ; /* Dummy for backward compatibility. */
3280             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
3281               ; /* Dummy for backward compatibility. */
3282             else if( !ascii_strcasecmp( keyword, "%no-protection" ) )
3283                 outctrl.keygen_flags |= KEYGEN_FLAG_NO_PROTECTION;
3284             else if( !ascii_strcasecmp( keyword, "%transient-key" ) )
3285                 outctrl.keygen_flags |= KEYGEN_FLAG_TRANSIENT_KEY;
3286             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
3287                 outctrl.lnr = lnr;
3288                 if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
3289                   print_status_key_not_created
3290                     (get_parameter_value (para, pHANDLE));
3291                 release_parameter_list( para );
3292                 para = NULL;
3293             }
3294             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
3295                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
3296                     ; /* still the same file - ignore it */
3297                 else {
3298                     xfree( outctrl.pub.newfname );
3299                     outctrl.pub.newfname = xstrdup( value );
3300                     outctrl.use_files = 1;
3301                 }
3302             }
3303             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
3304               /* Ignore this command.  */
3305             }
3306             else
3307                 log_info("skipping control '%s' (%s)\n", keyword, value );
3308
3309
3310             continue;
3311         }
3312
3313
3314         if( !(p = strchr( p, ':' )) || p == keyword ) {
3315             err = "missing colon";
3316             break;
3317         }
3318         if( *p )
3319             *p++ = 0;
3320         for( ; isspace(*(byte*)p); p++ )
3321             ;
3322         if( !*p ) {
3323             err = "missing argument";
3324             break;
3325         }
3326         value = p;
3327         trim_trailing_ws( value, strlen(value) );
3328
3329         for(i=0; keywords[i].name; i++ ) {
3330             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
3331                 break;
3332         }
3333         if( !keywords[i].name ) {
3334             err = "unknown keyword";
3335             break;
3336         }
3337         if( keywords[i].key != pKEYTYPE && !para ) {
3338             err = "parameter block does not start with \"Key-Type\"";
3339             break;
3340         }
3341
3342         if( keywords[i].key == pKEYTYPE && para ) {
3343             outctrl.lnr = lnr;
3344             if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
3345               print_status_key_not_created
3346                 (get_parameter_value (para, pHANDLE));
3347             release_parameter_list( para );
3348             para = NULL;
3349         }
3350         else {
3351             for( r = para; r; r = r->next ) {
3352                 if( r->key == keywords[i].key )
3353                     break;
3354             }
3355             if( r ) {
3356                 err = "duplicate keyword";
3357                 break;
3358             }
3359         }
3360         r = xmalloc_clear( sizeof *r + strlen( value ) );
3361         r->lnr = lnr;
3362         r->key = keywords[i].key;
3363         strcpy( r->u.value, value );
3364         r->next = para;
3365         para = r;
3366     }
3367     if( err )
3368         log_error("%s:%d: %s\n", fname, lnr, err );
3369     else if( iobuf_error (fp) ) {
3370         log_error("%s:%d: read error\n", fname, lnr);
3371     }
3372     else if( para ) {
3373         outctrl.lnr = lnr;
3374         if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
3375           print_status_key_not_created (get_parameter_value (para, pHANDLE));
3376     }
3377
3378     if( outctrl.use_files ) { /* close open streams */
3379         iobuf_close( outctrl.pub.stream );
3380
3381         /* Must invalidate that ugly cache to actually close it.  */
3382         if (outctrl.pub.fname)
3383           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3384                        0, (char*)outctrl.pub.fname);
3385
3386         xfree( outctrl.pub.fname );
3387         xfree( outctrl.pub.newfname );
3388     }
3389
3390     release_parameter_list( para );
3391     iobuf_close (fp);
3392     release_armor_context (outctrl.pub.afx);
3393 }
3394
3395
3396 /* Helper for quick_generate_keypair.  */
3397 static struct para_data_s *
3398 quickgen_set_para (struct para_data_s *para, int for_subkey,
3399                    int algo, int nbits, const char *curve)
3400 {
3401   struct para_data_s *r;
3402
3403   r = xmalloc_clear (sizeof *r + 20);
3404   r->key = for_subkey? pSUBKEYUSAGE :  pKEYUSAGE;
3405   strcpy (r->u.value, for_subkey ? "encrypt" : "sign");
3406   r->next = para;
3407   para = r;
3408   r = xmalloc_clear (sizeof *r + 20);
3409   r->key = for_subkey? pSUBKEYTYPE : pKEYTYPE;
3410   snprintf (r->u.value, 20, "%d", algo);
3411   r->next = para;
3412   para = r;
3413
3414   if (curve)
3415     {
3416       r = xmalloc_clear (sizeof *r + strlen (curve));
3417       r->key = for_subkey? pSUBKEYCURVE : pKEYCURVE;
3418       strcpy (r->u.value, curve);
3419       r->next = para;
3420       para = r;
3421     }
3422   else
3423     {
3424       r = xmalloc_clear (sizeof *r + 20);
3425       r->key = for_subkey? pSUBKEYLENGTH : pKEYLENGTH;
3426       sprintf (r->u.value, "%u", nbits);
3427       r->next = para;
3428       para = r;
3429     }
3430
3431   return para;
3432 }
3433
3434
3435 /*
3436  * Unattended generation of a standard key.
3437  */
3438 void
3439 quick_generate_keypair (ctrl_t ctrl, const char *uid)
3440 {
3441   gpg_error_t err;
3442   struct para_data_s *para = NULL;
3443   struct para_data_s *r;
3444   struct output_control_s outctrl;
3445   int use_tty;
3446
3447   memset (&outctrl, 0, sizeof outctrl);
3448
3449   use_tty = (!opt.batch && !opt.answer_yes
3450              && !cpr_enabled ()
3451              && gnupg_isatty (fileno (stdin))
3452              && gnupg_isatty (fileno (stdout))
3453              && gnupg_isatty (fileno (stderr)));
3454
3455   r = xmalloc_clear (sizeof *r + strlen (uid));
3456   r->key = pUSERID;
3457   strcpy (r->u.value, uid);
3458   r->next = para;
3459   para = r;
3460
3461   uid = trim_spaces (r->u.value);
3462   if (!*uid || (!opt.allow_freeform_uid && !is_valid_user_id (uid)))
3463     {
3464       log_error (_("Key generation failed: %s\n"),
3465                  gpg_strerror (GPG_ERR_INV_USER_ID));
3466       goto leave;
3467     }
3468
3469   /* If gpg is directly used on the console ask whether a key with the
3470      given user id shall really be created.  */
3471   if (use_tty)
3472     {
3473       tty_printf (_("About to create a key for:\n    \"%s\"\n\n"), uid);
3474       if (!cpr_get_answer_is_yes_def ("quick_keygen.okay",
3475                                       _("Continue? (Y/n) "), 1))
3476         goto leave;
3477     }
3478
3479   /* Check whether such a user ID already exists.  */
3480   {
3481     KEYDB_HANDLE kdbhd;
3482     KEYDB_SEARCH_DESC desc;
3483
3484     memset (&desc, 0, sizeof desc);
3485     desc.mode = KEYDB_SEARCH_MODE_EXACT;
3486     desc.u.name = uid;
3487
3488     kdbhd = keydb_new ();
3489     if (!kdbhd)
3490       goto leave;
3491
3492     err = keydb_search (kdbhd, &desc, 1, NULL);
3493     keydb_release (kdbhd);
3494     if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
3495       {
3496         log_info (_("A key for \"%s\" already exists\n"), uid);
3497         if (opt.answer_yes)
3498           ;
3499         else if (!use_tty
3500                  || !cpr_get_answer_is_yes_def ("quick_keygen.force",
3501                                                 _("Create anyway? (y/N) "), 0))
3502           {
3503             log_inc_errorcount ();  /* we used log_info */
3504             goto leave;
3505           }
3506         log_info (_("creating anyway\n"));
3507       }
3508   }
3509
3510   para = quickgen_set_para (para, 0,
3511                             DEFAULT_STD_ALGO, DEFAULT_STD_KEYSIZE,
3512                             DEFAULT_STD_CURVE);
3513   para = quickgen_set_para (para, 1,
3514                             DEFAULT_STD_SUBALGO, DEFAULT_STD_SUBKEYSIZE,
3515                             DEFAULT_STD_SUBCURVE);
3516
3517   /* If the pinentry loopback mode is not and we have a static
3518      passphrase (i.e. set with --passphrase{,-fd,-file} while in batch
3519      mode), we use that passphrase for the new key.  */
3520   if (opt.pinentry_mode != PINENTRY_MODE_LOOPBACK
3521       && have_static_passphrase ())
3522     {
3523       const char *s = get_static_passphrase ();
3524
3525       r = xmalloc_clear (sizeof *r + strlen (s));
3526       r->key = pPASSPHRASE;
3527       strcpy (r->u.value, s);
3528       r->next = para;
3529       para = r;
3530     }
3531
3532   proc_parameter_file (ctrl, para, "[internal]", &outctrl, 0);
3533  leave:
3534   release_parameter_list (para);
3535 }
3536
3537
3538 /*
3539  * Generate a keypair (fname is only used in batch mode) If
3540  * CARD_SERIALNO is not NULL the function will create the keys on an
3541  * OpenPGP Card.  If CARD_BACKUP_KEY has been set and CARD_SERIALNO is
3542  * NOT NULL, the encryption key for the card is generated on the host,
3543  * imported to the card and a backup file created by gpg-agent.  If
3544  * FULL is not set only the basic prompts are used (except for batch
3545  * mode).
3546  */
3547 void
3548 generate_keypair (ctrl_t ctrl, int full, const char *fname,
3549                   const char *card_serialno, int card_backup_key)
3550 {
3551   unsigned int nbits;
3552   char *uid = NULL;
3553   int algo;
3554   unsigned int use;
3555   int both = 0;
3556   u32 expire;
3557   struct para_data_s *para = NULL;
3558   struct para_data_s *r;
3559   struct output_control_s outctrl;
3560
3561 #ifndef ENABLE_CARD_SUPPORT
3562   (void)card_backup_key;
3563 #endif
3564
3565   memset( &outctrl, 0, sizeof( outctrl ) );
3566
3567   if (opt.batch && card_serialno)
3568     {
3569       /* We don't yet support unattended key generation. */
3570       log_error (_("can't do this in batch mode\n"));
3571       return;
3572     }
3573
3574   if (opt.batch)
3575     {
3576       read_parameter_file (ctrl, fname);
3577       return;
3578     }
3579
3580   if (card_serialno)
3581     {
3582 #ifdef ENABLE_CARD_SUPPORT
3583       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
3584       r->key = pSERIALNO;
3585       strcpy( r->u.value, card_serialno);
3586       r->next = para;
3587       para = r;
3588
3589       algo = PUBKEY_ALGO_RSA;
3590
3591       r = xcalloc (1, sizeof *r + 20 );
3592       r->key = pKEYTYPE;
3593       sprintf( r->u.value, "%d", algo );
3594       r->next = para;
3595       para = r;
3596       r = xcalloc (1, sizeof *r + 20 );
3597       r->key = pKEYUSAGE;
3598       strcpy (r->u.value, "sign");
3599       r->next = para;
3600       para = r;
3601
3602       r = xcalloc (1, sizeof *r + 20 );
3603       r->key = pSUBKEYTYPE;
3604       sprintf( r->u.value, "%d", algo );
3605       r->next = para;
3606       para = r;
3607       r = xcalloc (1, sizeof *r + 20 );
3608       r->key = pSUBKEYUSAGE;
3609       strcpy (r->u.value, "encrypt");
3610       r->next = para;
3611       para = r;
3612
3613       r = xcalloc (1, sizeof *r + 20 );
3614       r->key = pAUTHKEYTYPE;
3615       sprintf( r->u.value, "%d", algo );
3616       r->next = para;
3617       para = r;
3618
3619       if (card_backup_key)
3620         {
3621           r = xcalloc (1, sizeof *r + 1);
3622           r->key = pCARDBACKUPKEY;
3623           strcpy (r->u.value, "1");
3624           r->next = para;
3625           para = r;
3626         }
3627 #endif /*ENABLE_CARD_SUPPORT*/
3628     }
3629   else if (full)  /* Full featured key generation.  */
3630     {
3631       int subkey_algo;
3632       char *curve = NULL;
3633
3634       /* Fixme: To support creating a primary key by keygrip we better
3635          also define the keyword for the parameter file.  Note that
3636          the subkey case will never be asserted if a keygrip has been
3637          given.  */
3638       algo = ask_algo (ctrl, 0, &subkey_algo, &use, NULL);
3639       if (subkey_algo)
3640         {
3641           /* Create primary and subkey at once.  */
3642           both = 1;
3643           if (algo == PUBKEY_ALGO_ECDSA
3644               || algo == PUBKEY_ALGO_EDDSA
3645               || algo == PUBKEY_ALGO_ECDH)
3646             {
3647               curve = ask_curve (&algo, &subkey_algo);
3648               r = xmalloc_clear( sizeof *r + 20 );
3649               r->key = pKEYTYPE;
3650               sprintf( r->u.value, "%d", algo);
3651               r->next = para;
3652               para = r;
3653               nbits = 0;
3654               r = xmalloc_clear (sizeof *r + strlen (curve));
3655               r->key = pKEYCURVE;
3656               strcpy (r->u.value, curve);
3657               r->next = para;
3658               para = r;
3659             }
3660           else
3661             {
3662               r = xmalloc_clear( sizeof *r + 20 );
3663               r->key = pKEYTYPE;
3664               sprintf( r->u.value, "%d", algo);
3665               r->next = para;
3666               para = r;
3667               nbits = ask_keysize (algo, 0);
3668               r = xmalloc_clear( sizeof *r + 20 );
3669               r->key = pKEYLENGTH;
3670               sprintf( r->u.value, "%u", nbits);
3671               r->next = para;
3672               para = r;
3673             }
3674           r = xmalloc_clear( sizeof *r + 20 );
3675           r->key = pKEYUSAGE;
3676           strcpy( r->u.value, "sign" );
3677           r->next = para;
3678           para = r;
3679
3680           r = xmalloc_clear( sizeof *r + 20 );
3681           r->key = pSUBKEYTYPE;
3682           sprintf( r->u.value, "%d", subkey_algo);
3683           r->next = para;
3684           para = r;
3685           r = xmalloc_clear( sizeof *r + 20 );
3686           r->key = pSUBKEYUSAGE;
3687           strcpy( r->u.value, "encrypt" );
3688           r->next = para;
3689           para = r;
3690
3691           if (algo == PUBKEY_ALGO_ECDSA
3692               || algo == PUBKEY_ALGO_EDDSA
3693               || algo == PUBKEY_ALGO_ECDH)
3694             {
3695               if (algo == PUBKEY_ALGO_EDDSA
3696                   && subkey_algo == PUBKEY_ALGO_ECDH)
3697                 {
3698                   /* Need to switch to a different curve for the
3699                      encryption key.  */
3700                   xfree (curve);
3701                   curve = xstrdup ("Curve25519");
3702                 }
3703               r = xmalloc_clear (sizeof *r + strlen (curve));
3704               r->key = pSUBKEYCURVE;
3705               strcpy (r->u.value, curve);
3706               r->next = para;
3707               para = r;
3708             }
3709         }
3710       else /* Create only a single key.  */
3711         {
3712           /* For ECC we need to ask for the curve before storing the
3713              algo because ask_curve may change the algo.  */
3714           if (algo == PUBKEY_ALGO_ECDSA
3715               || algo == PUBKEY_ALGO_EDDSA
3716               || algo == PUBKEY_ALGO_ECDH)
3717             {
3718               curve = ask_curve (&algo, NULL);
3719               r = xmalloc_clear (sizeof *r + strlen (curve));
3720               r->key = pKEYCURVE;
3721               strcpy (r->u.value, curve);
3722               r->next = para;
3723               para = r;
3724             }
3725
3726           r = xmalloc_clear( sizeof *r + 20 );
3727           r->key = pKEYTYPE;
3728           sprintf( r->u.value, "%d", algo );
3729           r->next = para;
3730           para = r;
3731
3732           if (use)
3733             {
3734               r = xmalloc_clear( sizeof *r + 25 );
3735               r->key = pKEYUSAGE;
3736               sprintf( r->u.value, "%s%s%s",
3737                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
3738                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
3739                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
3740               r->next = para;
3741               para = r;
3742             }
3743           nbits = 0;
3744         }
3745
3746       if (algo == PUBKEY_ALGO_ECDSA
3747           || algo == PUBKEY_ALGO_EDDSA
3748           || algo == PUBKEY_ALGO_ECDH)
3749         {
3750           /* The curve has already been set.  */
3751         }
3752       else
3753         {
3754           nbits = ask_keysize (both? subkey_algo : algo, nbits);
3755           r = xmalloc_clear( sizeof *r + 20 );
3756           r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
3757           sprintf( r->u.value, "%u", nbits);
3758           r->next = para;
3759           para = r;
3760         }
3761
3762       xfree (curve);
3763     }
3764   else /* Default key generation.  */
3765     {
3766       tty_printf ( _("Note: Use \"%s %s\""
3767                      " for a full featured key generation dialog.\n"),
3768                    NAME_OF_INSTALLED_GPG, "--full-gen-key" );
3769       para = quickgen_set_para (para, 0,
3770                                 DEFAULT_STD_ALGO, DEFAULT_STD_KEYSIZE,
3771                                 DEFAULT_STD_CURVE);
3772       para = quickgen_set_para (para, 1,
3773                                 DEFAULT_STD_SUBALGO, DEFAULT_STD_SUBKEYSIZE,
3774                                 DEFAULT_STD_SUBCURVE);
3775     }
3776
3777
3778   expire = full? ask_expire_interval (0, NULL) : 0;
3779   r = xcalloc (1, sizeof *r + 20);
3780   r->key = pKEYEXPIRE;
3781   r->u.expire = expire;
3782   r->next = para;
3783   para = r;
3784   r = xcalloc (1, sizeof *r + 20);
3785   r->key = pSUBKEYEXPIRE;
3786   r->u.expire = expire;
3787   r->next = para;
3788   para = r;
3789
3790   uid = ask_user_id (0, full, NULL);
3791   if (!uid)
3792     {
3793       log_error(_("Key generation canceled.\n"));
3794       release_parameter_list( para );
3795       return;
3796     }
3797   r = xcalloc (1, sizeof *r + strlen (uid));
3798   r->key = pUSERID;
3799   strcpy (r->u.value, uid);
3800   r->next = para;
3801   para = r;
3802
3803   proc_parameter_file (ctrl, para, "[internal]", &outctrl, !!card_serialno);
3804   release_parameter_list (para);
3805 }
3806
3807
3808 /* Create and delete a dummy packet to start off a list of kbnodes. */
3809 static void
3810 start_tree(KBNODE *tree)
3811 {
3812   PACKET *pkt;
3813
3814   pkt=xmalloc_clear(sizeof(*pkt));
3815   pkt->pkttype=PKT_NONE;
3816   *tree=new_kbnode(pkt);
3817   delete_kbnode(*tree);
3818 }
3819
3820
3821 /* Write the *protected* secret key to the file.  */
3822 static gpg_error_t
3823 card_write_key_to_backup_file (PKT_public_key *sk, const char *backup_dir)
3824 {
3825   gpg_error_t err = 0;
3826   int rc;
3827   char name_buffer[50];
3828   char *fname;
3829   IOBUF fp;
3830   mode_t oldmask;
3831   PACKET *pkt = NULL;
3832
3833   keyid_from_pk (sk, NULL);
3834   snprintf (name_buffer, sizeof name_buffer, "sk_%08lX%08lX.gpg",
3835             (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
3836
3837   fname = make_filename (backup_dir, name_buffer, NULL);
3838   /* Note that the umask call is not anymore needed because
3839      iobuf_create now takes care of it.  However, it does not harm
3840      and thus we keep it.  */
3841   oldmask = umask (077);
3842   if (is_secured_filename (fname))
3843     {
3844       fp = NULL;
3845       gpg_err_set_errno (EPERM);
3846     }
3847   else
3848     fp = iobuf_create (fname, 1);
3849   umask (oldmask);
3850   if (!fp)
3851     {
3852       err = gpg_error_from_syserror ();
3853       log_error (_("can't create backup file '%s': %s\n"), fname, strerror (errno) );
3854       goto leave;
3855     }
3856
3857   pkt = xcalloc (1, sizeof *pkt);
3858   pkt->pkttype = PKT_SECRET_KEY;
3859   pkt->pkt.secret_key = sk;
3860
3861   rc = build_packet (fp, pkt);
3862   if (rc)
3863     {
3864       log_error ("build packet failed: %s\n", gpg_strerror (rc));
3865       iobuf_cancel (fp);
3866     }
3867   else
3868     {
3869       char *fprbuf;
3870
3871       iobuf_close (fp);
3872       iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
3873       log_info (_("Note: backup of card key saved to '%s'\n"), fname);
3874
3875       fprbuf = hexfingerprint (sk, NULL, 0);
3876       write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED, fprbuf,
3877                                     fname, strlen (fname), 0);
3878       xfree (fprbuf);
3879     }
3880
3881  leave:
3882   xfree (pkt);
3883   xfree (fname);
3884   return err;
3885 }
3886
3887
3888 /* Store key to card and make a backup file in OpenPGP format.  */
3889 static gpg_error_t
3890 card_store_key_with_backup (ctrl_t ctrl, PKT_public_key *sub_psk,
3891                             const char *backup_dir)
3892 {
3893   PKT_public_key *sk;
3894   gnupg_isotime_t timestamp;
3895   gpg_error_t err;
3896   char *hexgrip;
3897   int rc;
3898   struct agent_card_info_s info;
3899   gcry_cipher_hd_t cipherhd = NULL;
3900   char *cache_nonce = NULL;
3901   void *kek = NULL;
3902   size_t keklen;
3903
3904   sk = copy_public_key (NULL, sub_psk);
3905   if (!sk)
3906     return gpg_error_from_syserror ();
3907
3908   epoch2isotime (timestamp, (time_t)sk->timestamp);
3909   err = hexkeygrip_from_pk (sk, &hexgrip);
3910   if (err)
3911     return err;
3912
3913   memset(&info, 0, sizeof (info));
3914   rc = agent_scd_getattr ("SERIALNO", &info);
3915   if (rc)
3916     return (gpg_error_t)rc;
3917
3918   rc = agent_keytocard (hexgrip, 2, 1, info.serialno, timestamp);
3919   xfree (info.serialno);
3920   if (rc)
3921     {
3922       err = (gpg_error_t)rc;
3923       goto leave;
3924     }
3925
3926   err = agent_keywrap_key (ctrl, 1, &kek, &keklen);
3927   if (err)
3928     {
3929       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
3930       goto leave;
3931     }
3932
3933   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_AESWRAP, 0);
3934   if (!err)
3935     err = gcry_cipher_setkey (cipherhd, kek, keklen);
3936   if (err)
3937     {
3938       log_error ("error setting up an encryption context: %s\n", gpg_strerror (err));
3939       goto leave;
3940     }
3941
3942   err = receive_seckey_from_agent (ctrl, cipherhd, &cache_nonce, hexgrip, sk);
3943   if (err)
3944     {
3945       log_error ("error getting secret key from agent: %s\n", gpg_strerror (err));
3946       goto leave;
3947     }
3948
3949   err = card_write_key_to_backup_file (sk, backup_dir);
3950   if (err)
3951     log_error ("writing card key to backup file: %s\n", gpg_strerror (err));
3952   else
3953     /* Remove secret key data in agent side.  */
3954     agent_scd_learn (NULL, 1);
3955
3956  leave:
3957   xfree (cache_nonce);
3958   gcry_cipher_close (cipherhd);
3959   xfree (kek);
3960   xfree (hexgrip);
3961   free_public_key (sk);
3962   return err;
3963 }
3964
3965
3966 static void
3967 do_generate_keypair (ctrl_t ctrl, struct para_data_s *para,
3968                      struct output_control_s *outctrl, int card)
3969 {
3970   gpg_error_t err;
3971   KBNODE pub_root = NULL;
3972   const char *s;
3973   PKT_public_key *pri_psk = NULL;
3974   PKT_public_key *sub_psk = NULL;
3975   struct revocation_key *revkey;
3976   int did_sub = 0;
3977   u32 timestamp;
3978   char *cache_nonce = NULL;
3979
3980   if (outctrl->dryrun)
3981     {
3982       log_info("dry-run mode - key generation skipped\n");
3983       return;
3984     }
3985
3986   if ( outctrl->use_files )
3987     {
3988       if ( outctrl->pub.newfname )
3989         {
3990           iobuf_close(outctrl->pub.stream);
3991           outctrl->pub.stream = NULL;
3992           if (outctrl->pub.fname)
3993             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3994                          0, (char*)outctrl->pub.fname);
3995           xfree( outctrl->pub.fname );
3996           outctrl->pub.fname =  outctrl->pub.newfname;
3997           outctrl->pub.newfname = NULL;
3998
3999           if (is_secured_filename (outctrl->pub.fname) )
4000             {
4001               outctrl->pub.stream = NULL;
4002               gpg_err_set_errno (EPERM);
4003             }
4004           else
4005             outctrl->pub.stream = iobuf_create (outctrl->pub.fname, 0);
4006           if (!outctrl->pub.stream)
4007             {
4008               log_error(_("can't create '%s': %s\n"), outctrl->pub.newfname,
4009                         strerror(errno) );
4010               return;
4011             }
4012           if (opt.armor)
4013             {
4014               outctrl->pub.afx->what = 1;
4015               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
4016             }
4017         }
4018       assert( outctrl->pub.stream );
4019       if (opt.verbose)
4020         log_info (_("writing public key to '%s'\n"), outctrl->pub.fname );
4021     }
4022
4023
4024   /* We create the packets as a tree of kbnodes.  Because the
4025      structure we create is known in advance we simply generate a
4026      linked list.  The first packet is a dummy packet which we flag as
4027      deleted.  The very first packet must always be a KEY packet.  */
4028
4029   start_tree (&pub_root);
4030
4031   timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
4032   if (!timestamp)
4033     timestamp = make_timestamp ();
4034
4035   /* Note that, depending on the backend (i.e. the used scdaemon
4036      version), the card key generation may update TIMESTAMP for each
4037      key.  Thus we need to pass TIMESTAMP to all signing function to
4038      make sure that the binding signature is done using the timestamp
4039      of the corresponding (sub)key and not that of the primary key.
4040      An alternative implementation could tell the signing function the
4041      node of the subkey but that is more work than just to pass the
4042      current timestamp.  */
4043
4044   if (!card)
4045     err = do_create (get_parameter_algo( para, pKEYTYPE, NULL ),
4046                      get_parameter_uint( para, pKEYLENGTH ),
4047                      get_parameter_value (para, pKEYCURVE),
4048                      pub_root,
4049                      timestamp,
4050                      get_parameter_u32( para, pKEYEXPIRE ), 0,
4051                      outctrl->keygen_flags,
4052                      get_parameter_passphrase (para),
4053                      &cache_nonce);
4054   else
4055     err = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root,
4056                         &timestamp,
4057                         get_parameter_u32 (para, pKEYEXPIRE));
4058
4059   /* Get the pointer to the generated public key packet.  */
4060   if (!err)
4061     {
4062       pri_psk = pub_root->next->pkt->pkt.public_key;
4063       assert (pri_psk);
4064     }
4065
4066   if (!err && (revkey = get_parameter_revkey (para, pREVOKER)))
4067     err = write_direct_sig (pub_root, pri_psk, revkey, timestamp, cache_nonce);
4068
4069   if (!err && (s = get_parameter_value (para, pUSERID)))
4070     {
4071       write_uid (pub_root, s );
4072       err = write_selfsigs (pub_root, pri_psk,
4073                             get_parameter_uint (para, pKEYUSAGE), timestamp,
4074                             cache_nonce);
4075     }
4076
4077   /* Write the auth key to the card before the encryption key.  This
4078      is a partial workaround for a PGP bug (as of this writing, all
4079      versions including 8.1), that causes it to try and encrypt to
4080      the most recent subkey regardless of whether that subkey is
4081      actually an encryption type.  In this case, the auth key is an
4082      RSA key so it succeeds. */
4083
4084   if (!err && card && get_parameter (para, pAUTHKEYTYPE))
4085     {
4086       err = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root,
4087                           &timestamp,
4088                           get_parameter_u32 (para, pKEYEXPIRE));
4089       if (!err)
4090         err = write_keybinding (pub_root, pri_psk, NULL,
4091                                 PUBKEY_USAGE_AUTH, timestamp, cache_nonce);
4092     }
4093
4094   if (!err && get_parameter (para, pSUBKEYTYPE))
4095     {
4096       sub_psk = NULL;
4097       s = NULL;
4098       if (!card || (s = get_parameter_value (para, pCARDBACKUPKEY)))
4099         {
4100           err = do_create (get_parameter_algo (para, pSUBKEYTYPE, NULL),
4101                            get_parameter_uint (para, pSUBKEYLENGTH),
4102                            get_parameter_value (para, pSUBKEYCURVE),
4103                            pub_root,
4104                            timestamp,
4105                            get_parameter_u32 (para, pSUBKEYEXPIRE), 1,
4106                            s ? KEYGEN_FLAG_NO_PROTECTION : outctrl->keygen_flags,
4107                            get_parameter_passphrase (para),
4108                            &cache_nonce);
4109           /* Get the pointer to the generated public subkey packet.  */
4110           if (!err)
4111             {
4112               kbnode_t node;
4113
4114               for (node = pub_root; node; node = node->next)
4115                 if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
4116                   sub_psk = node->pkt->pkt.public_key;
4117               assert (sub_psk);
4118
4119               if (s)
4120                 err = card_store_key_with_backup (ctrl, sub_psk, opt.homedir);
4121             }
4122         }
4123       else
4124         {
4125           err = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, &timestamp,
4126                               get_parameter_u32 (para, pKEYEXPIRE));
4127         }
4128
4129       if (!err)
4130         err = write_keybinding (pub_root, pri_psk, sub_psk,
4131                                 get_parameter_uint (para, pSUBKEYUSAGE),
4132                                 timestamp, cache_nonce);
4133       did_sub = 1;
4134     }
4135
4136   if (!err && outctrl->use_files)  /* Direct write to specified files.  */
4137     {
4138       err = write_keyblock (outctrl->pub.stream, pub_root);
4139       if (err)
4140         log_error ("can't write public key: %s\n", gpg_strerror (err));
4141     }
4142   else if (!err) /* Write to the standard keyrings.  */
4143     {
4144       KEYDB_HANDLE pub_hd;
4145
4146       pub_hd = keydb_new ();
4147       if (!pub_hd)
4148         err = gpg_error_from_syserror ();
4149       else
4150         {
4151           err = keydb_locate_writable (pub_hd);
4152           if (err)
4153             log_error (_("no writable public keyring found: %s\n"),
4154                        gpg_strerror (err));
4155         }
4156
4157       if (!err && opt.verbose)
4158         {
4159           log_info (_("writing public key to '%s'\n"),
4160                     keydb_get_resource_name (pub_hd));
4161         }
4162
4163       if (!err)
4164         {
4165           err = keydb_insert_keyblock (pub_hd, pub_root);
4166           if (err)
4167             log_error (_("error writing public keyring '%s': %s\n"),
4168                        keydb_get_resource_name (pub_hd), gpg_strerror (err));
4169         }
4170
4171       keydb_release (pub_hd);
4172
4173       if (!err)
4174         {
4175           int no_enc_rsa;
4176           PKT_public_key *pk;
4177
4178           no_enc_rsa = ((get_parameter_algo (para, pKEYTYPE, NULL)
4179                          == PUBKEY_ALGO_RSA)
4180                         && get_parameter_uint (para, pKEYUSAGE)
4181                         && !((get_parameter_uint (para, pKEYUSAGE)
4182                               & PUBKEY_USAGE_ENC)) );
4183
4184           pk = find_kbnode (pub_root, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
4185
4186           keyid_from_pk (pk, pk->main_keyid);
4187           register_trusted_keyid (pk->main_keyid);
4188
4189           update_ownertrust (pk, ((get_ownertrust (pk) & ~TRUST_MASK)
4190                                   | TRUST_ULTIMATE ));
4191
4192           gen_standard_revoke (pk, cache_nonce);
4193
4194           if (!opt.batch)
4195             {
4196               tty_printf (_("public and secret key created and signed.\n") );
4197               tty_printf ("\n");
4198               list_keyblock_direct (ctrl, pub_root, 0, 1, 1);
4199             }
4200
4201
4202           if (!opt.batch
4203               && (get_parameter_algo (para, pKEYTYPE, NULL) == PUBKEY_ALGO_DSA
4204                   || no_enc_rsa )
4205               && !get_parameter (para, pSUBKEYTYPE) )
4206             {
4207               tty_printf(_("Note that this key cannot be used for "
4208                            "encryption.  You may want to use\n"
4209                            "the command \"--edit-key\" to generate a "
4210                            "subkey for this purpose.\n") );
4211             }
4212         }
4213     }
4214
4215   if (err)
4216     {
4217       if (opt.batch)
4218         log_error ("key generation failed: %s\n", gpg_strerror (err) );
4219       else
4220         tty_printf (_("Key generation failed: %s\n"), gpg_strerror (err) );
4221       write_status_error (card? "card_key_generate":"key_generate", err);
4222       print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
4223     }
4224   else
4225     {
4226       PKT_public_key *pk = find_kbnode (pub_root,
4227                                         PKT_PUBLIC_KEY)->pkt->pkt.public_key;
4228       print_status_key_created (did_sub? 'B':'P', pk,
4229                                 get_parameter_value (para, pHANDLE));
4230     }
4231
4232   release_kbnode (pub_root);
4233   xfree (cache_nonce);
4234 }
4235
4236
4237 /* Add a new subkey to an existing key.  Returns 0 if a new key has
4238    been generated and put into the keyblocks.  */
4239 gpg_error_t
4240 generate_subkeypair (ctrl_t ctrl, kbnode_t keyblock)
4241 {
4242   gpg_error_t err = 0;
4243   kbnode_t node;
4244   PKT_public_key *pri_psk = NULL;
4245   PKT_public_key *sub_psk = NULL;
4246   int algo;
4247   unsigned int use;
4248   u32 expire;
4249   unsigned int nbits = 0;
4250   char *curve = NULL;
4251   u32 cur_time;
4252   char *hexgrip = NULL;
4253   char *serialno = NULL;
4254
4255   /* Break out the primary key.  */
4256   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
4257   if (!node)
4258     {
4259       log_error ("Oops; primary key missing in keyblock!\n");
4260       err = gpg_error (GPG_ERR_BUG);
4261       goto leave;
4262     }
4263   pri_psk = node->pkt->pkt.public_key;
4264
4265   cur_time = make_timestamp ();
4266
4267   if (pri_psk->timestamp > cur_time)
4268     {
4269       ulong d = pri_psk->timestamp - cur_time;
4270       log_info ( d==1 ? _("key has been created %lu second "
4271                           "in future (time warp or clock problem)\n")
4272                  : _("key has been created %lu seconds "
4273                      "in future (time warp or clock problem)\n"), d );
4274       if (!opt.ignore_time_conflict)
4275         {
4276           err = gpg_error (GPG_ERR_TIME_CONFLICT);
4277           goto leave;
4278         }
4279     }
4280
4281   if (pri_psk->version < 4)
4282     {
4283       log_info (_("Note: creating subkeys for v3 keys "