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