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