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