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