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