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