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