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