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