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