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