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