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