Merged with gpg 1.4.3 code.
[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(!check_cipher_algo(CIPHER_ALGO_AES256))
323               strcat(dummy_string,"S9 ");
324             if(!check_cipher_algo(CIPHER_ALGO_AES192))
325               strcat(dummy_string,"S8 ");
326             if(!check_cipher_algo(CIPHER_ALGO_AES))
327               strcat(dummy_string,"S7 ");
328             if(!check_cipher_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(!check_cipher_algo(CIPHER_ALGO_IDEA))
339               strcat(dummy_string,"S1 ");
340
341             /* SHA-1 */
342             strcat(dummy_string,"H2 ");
343
344             if(!check_digest_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=string_to_cipher_algo(tok)))
374               {
375                 if(set_one_pref(val,1,tok,sym,&nsym))
376                   rc=-1;
377               }
378             else if((val=string_to_digest_algo(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   size_t n;
1075   char *buf;
1076   
1077   if (misc_key_info)
1078     {
1079       /* DSA: don't know whether it makes sense to have the factors, so for now
1080          we store them in the secret keyring (but they are not secret)
1081          p = 2 * q * f1 * f2 * ... * fn
1082          We store only f1 to f_n-1;  fn can be calculated because p and q
1083          are known. */
1084       n = gcry_sexp_sprint (misc_key_info, 0, NULL, 0);
1085       buf = xmalloc (n+4);
1086       strcpy (buf, "#::");
1087       n = gcry_sexp_sprint (misc_key_info, 0, buf+3, n);
1088       if (n)
1089         {
1090           n += 3;
1091           add_kbnode (sec_root, make_comment_node_from_buffer (buf, n));
1092         }
1093       xfree (buf);
1094       gcry_sexp_release (misc_key_info);
1095     }
1096 }
1097
1098
1099 static int
1100 gen_elg(int algo, unsigned int nbits,
1101         KBNODE pub_root, KBNODE sec_root, DEK *dek,
1102         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval,
1103         int is_subkey)
1104 {
1105     int rc;
1106     PACKET *pkt;
1107     PKT_secret_key *sk;
1108     PKT_public_key *pk;
1109     gcry_sexp_t s_parms, s_key;
1110     gcry_sexp_t misc_key_info;
1111
1112     assert( is_ELGAMAL(algo) );
1113
1114     if( nbits < 512 ) {
1115         nbits = 1024;
1116         log_info(_("keysize invalid; using %u bits\n"), nbits );
1117     }
1118
1119     if( (nbits % 32) ) {
1120         nbits = ((nbits + 31) / 32) * 32;
1121         log_info(_("keysize rounded up to %u bits\n"), nbits );
1122     }
1123
1124
1125     rc = gcry_sexp_build ( &s_parms, NULL,
1126                            "(genkey(%s(nbits %d)))",
1127                            algo == GCRY_PK_ELG_E ? "openpgp-elg" :
1128                            algo == GCRY_PK_ELG   ? "elg" : "x-oops" ,
1129                            (int)nbits);
1130     if (rc)
1131       log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
1132   
1133     rc = gcry_pk_genkey (&s_key, s_parms);
1134     gcry_sexp_release (s_parms);
1135     if (rc)
1136       {
1137         log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
1138         return rc;
1139       }
1140
1141     sk = xmalloc_clear( sizeof *sk );
1142     pk = xmalloc_clear( sizeof *pk );
1143     sk->timestamp = pk->timestamp = make_timestamp();
1144     sk->version = pk->version = 4;
1145     if( expireval ) {
1146         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1147     }
1148     sk->pubkey_algo = pk->pubkey_algo = algo;
1149 /*                     pk->pkey[0] = mpi_copy( skey[0] ); */
1150 /*                     pk->pkey[1] = mpi_copy( skey[1] ); */
1151 /*                     pk->pkey[2] = mpi_copy( skey[2] ); */
1152 /*     sk->skey[0] = skey[0]; */
1153 /*     sk->skey[1] = skey[1]; */
1154 /*     sk->skey[2] = skey[2]; */
1155 /*     sk->skey[3] = skey[3]; */
1156
1157     rc = key_from_sexp (pk->pkey, s_key, "public-key", "pgy");
1158     if (rc) 
1159       {
1160         log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1161         gcry_sexp_release (s_key);
1162         free_secret_key (sk);
1163         free_public_key (pk);
1164         return rc;
1165       }
1166     rc = key_from_sexp (sk->skey, s_key, "private-key", "pgyx");
1167     if (rc)
1168       {
1169         log_error("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1170         gcry_sexp_release (s_key);
1171         free_secret_key (sk);
1172         free_public_key (pk);
1173         return rc;
1174       }
1175     misc_key_info = gcry_sexp_find_token (s_key, "misc-key-info", 0);
1176     gcry_sexp_release (s_key);
1177   
1178     sk->is_protected = 0;
1179     sk->protect.algo = 0;
1180
1181     sk->csum = checksum_mpi( sk->skey[3] );
1182     if( ret_sk ) /* return an unprotected version of the sk */
1183         *ret_sk = copy_secret_key( NULL, sk );
1184
1185     rc = genhelp_protect (dek, s2k, sk);
1186     if (rc)
1187       {
1188         free_public_key (pk);
1189         free_secret_key (sk);
1190         gcry_sexp_release (misc_key_info);
1191         return rc;
1192       }
1193
1194     pkt = xmalloc_clear (sizeof *pkt);
1195     pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1196     pkt->pkt.public_key = pk;
1197     add_kbnode(pub_root, new_kbnode( pkt ));
1198
1199     /* Don't know whether it makes sense to have the factors, so for now
1200      * we store them in the secret keyring (but they are not secret). */
1201     pkt = xmalloc_clear(sizeof *pkt);
1202     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1203     pkt->pkt.secret_key = sk;
1204     add_kbnode(sec_root, new_kbnode( pkt ));
1205
1206     genhelp_factors (misc_key_info, sec_root);
1207
1208     return 0;
1209 }
1210
1211
1212 /****************
1213  * Generate a DSA key
1214  */
1215 static int
1216 gen_dsa (unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
1217         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
1218 {
1219     int rc;
1220     PACKET *pkt;
1221     PKT_secret_key *sk;
1222     PKT_public_key *pk;
1223     gcry_sexp_t s_parms, s_key;
1224     gcry_sexp_t misc_key_info;
1225
1226     if( nbits > 1024 || nbits < 512 ) {
1227         nbits = 1024;
1228         log_info(_("keysize invalid; using %u bits\n"), nbits );
1229     }
1230
1231     if( (nbits % 64) ) {
1232         nbits = ((nbits + 63) / 64) * 64;
1233         log_info(_("keysize rounded up to %u bits\n"), nbits );
1234     }
1235
1236     rc = gcry_sexp_build (&s_parms, NULL,
1237                           "(genkey(dsa(nbits %d)))",
1238                           (int)nbits);
1239     if (rc)
1240       log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
1241   
1242     rc = gcry_pk_genkey (&s_key, s_parms);
1243     gcry_sexp_release (s_parms);
1244     if (rc)
1245       {
1246         log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
1247         return rc;
1248       }
1249
1250     sk = xmalloc_clear( sizeof *sk );
1251     pk = xmalloc_clear( sizeof *pk );
1252     sk->timestamp = pk->timestamp = make_timestamp();
1253     sk->version = pk->version = 4;
1254     if( expireval ) {
1255         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1256     }
1257     sk->pubkey_algo = pk->pubkey_algo = PUBKEY_ALGO_DSA;
1258
1259     rc = key_from_sexp (pk->pkey, s_key, "public-key", "pqgy");
1260     if (rc) 
1261       {
1262         log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc));
1263         gcry_sexp_release (s_key);
1264         free_public_key(pk);
1265         free_secret_key(sk);
1266         return rc;
1267       }
1268     rc = key_from_sexp (sk->skey, s_key, "private-key", "pqgyx");
1269     if (rc) 
1270       {
1271         log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1272         gcry_sexp_release (s_key);
1273         free_public_key(pk);
1274         free_secret_key(sk);
1275         return rc;
1276       }
1277     misc_key_info = gcry_sexp_find_token (s_key, "misc-key-info", 0);
1278     gcry_sexp_release (s_key);
1279   
1280     sk->is_protected = 0;
1281     sk->protect.algo = 0;
1282
1283     sk->csum = checksum_mpi ( sk->skey[4] );
1284     if( ret_sk ) /* return an unprotected version of the sk */
1285         *ret_sk = copy_secret_key( NULL, sk );
1286
1287     rc = genhelp_protect (dek, s2k, sk);
1288     if (rc)
1289       {
1290         free_public_key (pk);
1291         free_secret_key (sk);
1292         gcry_sexp_release (misc_key_info);
1293         return rc;
1294       }
1295
1296     pkt = xmalloc_clear(sizeof *pkt);
1297     pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1298     pkt->pkt.public_key = pk;
1299     add_kbnode(pub_root, new_kbnode( pkt ));
1300
1301     /* Don't know whether it makes sense to have the factors, so for now
1302      * we store them in the secret keyring (but they are not secret)
1303      * p = 2 * q * f1 * f2 * ... * fn
1304      * We store only f1 to f_n-1;  fn can be calculated because p and q
1305      * are known.
1306      */
1307     pkt = xmalloc_clear(sizeof *pkt);
1308     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1309     pkt->pkt.secret_key = sk;
1310     add_kbnode(sec_root, new_kbnode( pkt ));
1311
1312     genhelp_factors (misc_key_info, sec_root);
1313
1314     return 0;
1315 }
1316
1317
1318 /* 
1319  * Generate an RSA key.
1320  */
1321 static int
1322 gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
1323         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval, int is_subkey)
1324 {
1325     int rc;
1326     PACKET *pkt;
1327     PKT_secret_key *sk;
1328     PKT_public_key *pk;
1329     gcry_sexp_t s_parms, s_key;
1330
1331     assert( is_RSA(algo) );
1332
1333     if( nbits < 1024 ) {
1334         nbits = 1024;
1335         log_info(_("keysize invalid; using %u bits\n"), nbits );
1336     }
1337
1338     if( (nbits % 32) ) {
1339         nbits = ((nbits + 31) / 32) * 32;
1340         log_info(_("keysize rounded up to %u bits\n"), nbits );
1341     }
1342
1343     rc = gcry_sexp_build (&s_parms, NULL,
1344                           "(genkey(rsa(nbits %d)))",
1345                           (int)nbits);
1346     if (rc)
1347       log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
1348   
1349     rc = gcry_pk_genkey (&s_key, s_parms);
1350     gcry_sexp_release (s_parms);
1351     if (rc)
1352       {
1353         log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
1354         return rc;
1355       }
1356
1357     sk = xmalloc_clear( sizeof *sk );
1358     pk = xmalloc_clear( sizeof *pk );
1359     sk->timestamp = pk->timestamp = make_timestamp();
1360     sk->version = pk->version = 4;
1361     if( expireval ) {
1362         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1363     }
1364     sk->pubkey_algo = pk->pubkey_algo = algo;
1365
1366     rc = key_from_sexp (pk->pkey, s_key, "public-key", "ne");
1367     if (rc) 
1368       {
1369         log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc));
1370         gcry_sexp_release (s_key);
1371         free_public_key(pk);
1372         free_secret_key(sk);
1373         return rc;
1374       }
1375     rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
1376     if (rc) 
1377       {
1378         log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1379         gcry_sexp_release (s_key);
1380         free_public_key(pk);
1381         free_secret_key(sk);
1382         return rc;
1383       }
1384     gcry_sexp_release (s_key);
1385
1386     sk->is_protected = 0;
1387     sk->protect.algo = 0;
1388
1389     sk->csum  = checksum_mpi (sk->skey[2] );
1390     sk->csum += checksum_mpi (sk->skey[3] );
1391     sk->csum += checksum_mpi (sk->skey[4] );
1392     sk->csum += checksum_mpi (sk->skey[5] );
1393     if( ret_sk ) /* return an unprotected version of the sk */
1394         *ret_sk = copy_secret_key( NULL, sk );
1395
1396     rc = genhelp_protect (dek, s2k, sk);
1397     if (rc)
1398       {
1399         free_public_key (pk);
1400         free_secret_key (sk);
1401         return rc;
1402       }
1403
1404     pkt = xmalloc_clear(sizeof *pkt);
1405     pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1406     pkt->pkt.public_key = pk;
1407     add_kbnode(pub_root, new_kbnode( pkt ));
1408
1409     pkt = xmalloc_clear(sizeof *pkt);
1410     pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1411     pkt->pkt.secret_key = sk;
1412     add_kbnode(sec_root, new_kbnode( pkt ));
1413
1414     return 0;
1415 }
1416
1417
1418 /****************
1419  * check valid days:
1420  * return 0 on error or the multiplier
1421  */
1422 static int
1423 check_valid_days( const char *s )
1424 {
1425     if( !digitp(s) )
1426         return 0;
1427     for( s++; *s; s++)
1428         if( !digitp(s) )
1429             break;
1430     if( !*s )
1431         return 1;
1432     if( s[1] )
1433         return 0; /* e.g. "2323wc" */
1434     if( *s == 'd' || *s == 'D' )
1435         return 1;
1436     if( *s == 'w' || *s == 'W' )
1437         return 7;
1438     if( *s == 'm' || *s == 'M' )
1439         return 30;
1440     if( *s == 'y' || *s == 'Y' )
1441         return 365;
1442     return 0;
1443 }
1444
1445
1446 static void
1447 print_key_flags(int flags)
1448 {
1449   if(flags&PUBKEY_USAGE_SIG)
1450     tty_printf("%s ",_("Sign"));
1451
1452   if(flags&PUBKEY_USAGE_CERT)
1453     tty_printf("%s ",_("Certify"));
1454
1455   if(flags&PUBKEY_USAGE_ENC)
1456     tty_printf("%s ",_("Encrypt"));
1457
1458   if(flags&PUBKEY_USAGE_AUTH)
1459     tty_printf("%s ",_("Authenticate"));
1460 }
1461
1462
1463 /* Returns the key flags */
1464 static unsigned int
1465 ask_key_flags(int algo,int subkey)
1466 {
1467   const char *togglers=_("SsEeAaQq");
1468   char *answer=NULL;
1469   unsigned int current=0;
1470   unsigned int possible=openpgp_pk_algo_usage(algo);
1471
1472   if(strlen(togglers)!=8)
1473     BUG();
1474
1475   /* Only primary keys may certify. */
1476   if(subkey)
1477     possible&=~PUBKEY_USAGE_CERT;
1478
1479   /* Preload the current set with the possible set, minus
1480      authentication, since nobody really uses auth yet. */
1481   current=possible&~PUBKEY_USAGE_AUTH;
1482
1483   for(;;)
1484     {
1485       tty_printf("\n");
1486       tty_printf(_("Possible actions for a %s key: "),
1487                  pubkey_algo_to_string(algo));
1488       print_key_flags(possible);
1489       tty_printf("\n");
1490       tty_printf(_("Current allowed actions: "));
1491       print_key_flags(current);
1492       tty_printf("\n\n");
1493
1494       if(possible&PUBKEY_USAGE_SIG)
1495         tty_printf(_("   (%c) Toggle the sign capability\n"),
1496                    togglers[0]);
1497       if(possible&PUBKEY_USAGE_ENC)
1498         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
1499                    togglers[2]);
1500       if(possible&PUBKEY_USAGE_AUTH)
1501         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
1502                    togglers[4]);
1503
1504       tty_printf(_("   (%c) Finished\n"),togglers[6]);
1505       tty_printf("\n");
1506
1507       xfree(answer);
1508       answer = cpr_get("keygen.flags",_("Your selection? "));
1509       cpr_kill_prompt();
1510
1511       if(strlen(answer)>1)
1512         tty_printf(_("Invalid selection.\n"));
1513       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1514         break;
1515       else if((*answer==togglers[0] || *answer==togglers[1])
1516               && possible&PUBKEY_USAGE_SIG)
1517         {
1518           if(current&PUBKEY_USAGE_SIG)
1519             current&=~PUBKEY_USAGE_SIG;
1520           else
1521             current|=PUBKEY_USAGE_SIG;
1522         }
1523       else if((*answer==togglers[2] || *answer==togglers[3])
1524               && possible&PUBKEY_USAGE_ENC)
1525         {
1526           if(current&PUBKEY_USAGE_ENC)
1527             current&=~PUBKEY_USAGE_ENC;
1528           else
1529             current|=PUBKEY_USAGE_ENC;
1530         }
1531       else if((*answer==togglers[4] || *answer==togglers[5])
1532               && possible&PUBKEY_USAGE_AUTH)
1533         {
1534           if(current&PUBKEY_USAGE_AUTH)
1535             current&=~PUBKEY_USAGE_AUTH;
1536           else
1537             current|=PUBKEY_USAGE_AUTH;
1538         }
1539       else
1540         tty_printf(_("Invalid selection.\n"));
1541     }
1542
1543   xfree(answer);
1544
1545   return current;
1546 }
1547
1548
1549 /****************
1550  * Returns: 0 to create both a DSA and a Elgamal key.
1551  *          and only if key flags are to be written the desired usage.
1552  */
1553 static int
1554 ask_algo (int addmode, unsigned int *r_usage)
1555 {
1556     char *answer;
1557     int algo;
1558
1559     *r_usage = 0;
1560     tty_printf(_("Please select what kind of key you want:\n"));
1561     if( !addmode )
1562         tty_printf(_("   (%d) DSA and Elgamal (default)\n"), 1 );
1563     tty_printf(    _("   (%d) DSA (sign only)\n"), 2 );
1564     if (opt.expert)
1565       tty_printf(  _("   (%d) DSA (set your own capabilities)\n"), 3 );
1566     if( addmode )
1567         tty_printf(_("   (%d) Elgamal (encrypt only)\n"), 4 );
1568     tty_printf(    _("   (%d) RSA (sign only)\n"), 5 );
1569     if (addmode)
1570         tty_printf(_("   (%d) RSA (encrypt only)\n"), 6 );
1571     if (opt.expert)
1572       tty_printf(  _("   (%d) RSA (set your own capabilities)\n"), 7 );
1573
1574     for(;;) {
1575         answer = cpr_get("keygen.algo",_("Your selection? "));
1576         cpr_kill_prompt();
1577         algo = *answer? atoi(answer): 1;
1578         xfree(answer);
1579         if( algo == 1 && !addmode ) {
1580             algo = 0;   /* create both keys */
1581             break;
1582         }
1583         else if( algo == 7 && opt.expert ) {
1584             algo = PUBKEY_ALGO_RSA;
1585             *r_usage=ask_key_flags(algo,addmode);
1586             break;
1587         }
1588         else if( algo == 6 && addmode ) {
1589             algo = PUBKEY_ALGO_RSA;
1590             *r_usage = PUBKEY_USAGE_ENC;
1591             break;
1592         }
1593         else if( algo == 5 ) {
1594             algo = PUBKEY_ALGO_RSA;
1595             *r_usage = PUBKEY_USAGE_SIG;
1596             break;
1597         }
1598         else if( algo == 4 && addmode ) {
1599             algo = PUBKEY_ALGO_ELGAMAL_E;
1600             *r_usage = PUBKEY_USAGE_ENC;
1601             break;
1602         }
1603         else if( algo == 3 && opt.expert ) {
1604             algo = PUBKEY_ALGO_DSA;
1605             *r_usage=ask_key_flags(algo,addmode);
1606             break;
1607         }
1608         else if( algo == 2 ) {
1609             algo = PUBKEY_ALGO_DSA;
1610             *r_usage = PUBKEY_USAGE_SIG;
1611             break;
1612         }
1613         else
1614             tty_printf(_("Invalid selection.\n"));
1615     }
1616
1617     return algo;
1618 }
1619
1620
1621 static unsigned
1622 ask_keysize( int algo )
1623 {
1624   unsigned int nbits, min, def=2048, max=4096;
1625
1626   if(opt.expert)
1627     min=512;
1628   else
1629     min=1024;
1630
1631   switch(algo)
1632     {
1633     case PUBKEY_ALGO_DSA:
1634       if(opt.expert)
1635         {
1636           def=1024;
1637           max=1024;
1638         }
1639       else
1640         {
1641           tty_printf(_("DSA keypair will have %u bits.\n"),1024);
1642           return 1024;
1643         }
1644       break;
1645
1646     case PUBKEY_ALGO_RSA:
1647       min=1024;
1648       break;
1649     }
1650
1651   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
1652              pubkey_algo_to_string(algo),min,max);
1653
1654   for(;;)
1655     {
1656       char *prompt,*answer;
1657
1658 #define PROMPTSTRING _("What keysize do you want? (%u) ")
1659
1660       prompt=xmalloc(strlen(PROMPTSTRING)+20);
1661       sprintf(prompt,PROMPTSTRING,def);
1662
1663 #undef PROMPTSTRING
1664
1665       answer = cpr_get("keygen.size",prompt);
1666       cpr_kill_prompt();
1667       nbits = *answer? atoi(answer): def;
1668       xfree(prompt);
1669       xfree(answer);
1670       
1671       if(nbits<min || nbits>max)
1672         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
1673                    pubkey_algo_to_string(algo),min,max);
1674       else
1675         break;
1676     }
1677
1678   tty_printf(_("Requested keysize is %u bits\n"), nbits );
1679
1680   if( algo == PUBKEY_ALGO_DSA && (nbits % 64) )
1681     {
1682       nbits = ((nbits + 63) / 64) * 64;
1683       tty_printf(_("rounded up to %u bits\n"), nbits );
1684     }
1685   else if( (nbits % 32) )
1686     {
1687       nbits = ((nbits + 31) / 32) * 32;
1688       tty_printf(_("rounded up to %u bits\n"), nbits );
1689     }
1690
1691   return nbits;
1692 }
1693
1694
1695 /****************
1696  * Parse an expire string and return its value in seconds.
1697  * Returns (u32)-1 on error.
1698  * This isn't perfect since scan_isodatestr returns unix time, and
1699  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
1700  * Because of this, we only permit setting expirations up to 2106, but
1701  * OpenPGP could theoretically allow up to 2242.  I think we'll all
1702  * just cope for the next few years until we get a 64-bit time_t or
1703  * similar.
1704  */
1705 u32
1706 parse_expire_string( const char *string )
1707 {
1708     int mult;
1709     u32 seconds,abs_date=0,curtime = make_timestamp();
1710
1711     if( !*string )
1712       seconds = 0;
1713     else if ( !strncmp (string, "seconds=", 8) )
1714       seconds = atoi (string+8);
1715     else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime )
1716       seconds = abs_date - curtime;
1717     else if( (mult=check_valid_days(string)) )
1718       seconds = atoi(string) * 86400L * mult;
1719     else
1720       seconds=(u32)-1;
1721
1722     return seconds;
1723 }
1724
1725 /* object == 0 for a key, and 1 for a sig */
1726 u32
1727 ask_expire_interval(int object,const char *def_expire)
1728 {
1729     u32 interval;
1730     char *answer;
1731
1732     switch(object)
1733       {
1734       case 0:
1735         if(def_expire)
1736           BUG();
1737         tty_printf(_("Please specify how long the key should be valid.\n"
1738                      "         0 = key does not expire\n"
1739                      "      <n>  = key expires in n days\n"
1740                      "      <n>w = key expires in n weeks\n"
1741                      "      <n>m = key expires in n months\n"
1742                      "      <n>y = key expires in n years\n"));
1743         break;
1744
1745       case 1:
1746         if(!def_expire)
1747           BUG();
1748         tty_printf(_("Please specify how long the signature should be valid.\n"
1749                      "         0 = signature does not expire\n"
1750                      "      <n>  = signature expires in n days\n"
1751                      "      <n>w = signature expires in n weeks\n"
1752                      "      <n>m = signature expires in n months\n"
1753                      "      <n>y = signature expires in n years\n"));
1754         break;
1755
1756       default:
1757         BUG();
1758       }
1759
1760     /* Note: The elgamal subkey for DSA has no expiration date because
1761      * it must be signed with the DSA key and this one has the expiration
1762      * date */
1763
1764     answer = NULL;
1765     for(;;)
1766       {
1767         u32 curtime=make_timestamp();
1768
1769         xfree(answer);
1770         if(object==0)
1771           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1772         else
1773           {
1774             char *prompt;
1775
1776 #define PROMPTSTRING _("Signature is valid for? (%s) ")
1777             /* This will actually end up larger than necessary because
1778                of the 2 bytes for '%s' */
1779             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
1780             sprintf(prompt,PROMPTSTRING,def_expire);
1781 #undef PROMPTSTRING
1782
1783             answer = cpr_get("siggen.valid",prompt);
1784             xfree(prompt);
1785
1786             if(*answer=='\0')
1787               answer=xstrdup(def_expire);
1788           }
1789         cpr_kill_prompt();
1790         trim_spaces(answer);
1791         interval = parse_expire_string( answer );
1792         if( interval == (u32)-1 )
1793           {
1794             tty_printf(_("invalid value\n"));
1795             continue;
1796           }
1797
1798         if( !interval )
1799           {
1800             tty_printf((object==0)
1801                        ? _("Key does not expire at all\n")
1802                        : _("Signature does not expire at all\n"));
1803           }
1804         else
1805           {
1806             tty_printf(object==0
1807                        ? _("Key expires at %s\n")
1808                        : _("Signature expires at %s\n"),
1809                        asctimestamp((ulong)(curtime + interval) ) );
1810             /* FIXME: This check yields warning on alhas: Write a
1811                configure check and to this check here only for 32 bit
1812                machines */
1813             if( (time_t)((ulong)(curtime+interval)) < 0 )
1814               tty_printf(_("Your system can't display dates beyond 2038.\n"
1815                            "However, it will be correctly handled up to 2106.\n"));
1816           }
1817
1818         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1819                                                    _("Is this correct? (y/N) ")) )
1820           break;
1821       }
1822
1823     xfree(answer);
1824     return interval;
1825 }
1826
1827 u32
1828 ask_expiredate()
1829 {
1830     u32 x = ask_expire_interval(0,NULL);
1831     return x? make_timestamp() + x : 0;
1832 }
1833
1834
1835 static char *
1836 ask_user_id( int mode )
1837 {
1838     char *answer;
1839     char *aname, *acomment, *amail, *uid;
1840
1841     if( !mode )
1842         tty_printf( _("\n"
1843 "You need a user ID to identify your key; "
1844                                         "the software constructs the user ID\n"
1845 "from the Real Name, Comment and Email Address in this form:\n"
1846 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
1847     uid = aname = acomment = amail = NULL;
1848     for(;;) {
1849         char *p;
1850         int fail=0;
1851
1852         if( !aname ) {
1853             for(;;) {
1854                 xfree(aname);
1855                 aname = cpr_get("keygen.name",_("Real name: "));
1856                 trim_spaces(aname);
1857                 cpr_kill_prompt();
1858
1859                 if( opt.allow_freeform_uid )
1860                     break;
1861
1862                 if( strpbrk( aname, "<>" ) )
1863                     tty_printf(_("Invalid character in name\n"));
1864                 else if( digitp(aname) )
1865                     tty_printf(_("Name may not start with a digit\n"));
1866                 else if( strlen(aname) < 5 )
1867                     tty_printf(_("Name must be at least 5 characters long\n"));
1868                 else
1869                     break;
1870             }
1871         }
1872         if( !amail ) {
1873             for(;;) {
1874                 xfree(amail);
1875                 amail = cpr_get("keygen.email",_("Email address: "));
1876                 trim_spaces(amail);
1877                 cpr_kill_prompt();
1878                 if( !*amail || opt.allow_freeform_uid )
1879                     break;   /* no email address is okay */
1880                 else if ( !is_valid_mailbox (amail) )
1881                     tty_printf(_("Not a valid email address\n"));
1882                 else
1883                     break;
1884             }
1885         }
1886         if( !acomment ) {
1887             for(;;) {
1888                 xfree(acomment);
1889                 acomment = cpr_get("keygen.comment",_("Comment: "));
1890                 trim_spaces(acomment);
1891                 cpr_kill_prompt();
1892                 if( !*acomment )
1893                     break;   /* no comment is okay */
1894                 else if( strpbrk( acomment, "()" ) )
1895                     tty_printf(_("Invalid character in comment\n"));
1896                 else
1897                     break;
1898             }
1899         }
1900
1901
1902         xfree(uid);
1903         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1904         p = stpcpy(p, aname );
1905         if( *acomment )
1906             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1907         if( *amail )
1908             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1909
1910         /* append a warning if we do not have dev/random
1911          * or it is switched into  quick testmode */
1912         if( quick_random_gen(-1) )
1913             strcpy(p, " (INSECURE!)" );
1914
1915         /* print a note in case that UTF8 mapping has to be done */
1916         for(p=uid; *p; p++ ) {
1917             if( *p & 0x80 ) {
1918                 tty_printf(_("You are using the `%s' character set.\n"),
1919                            get_native_charset() );
1920                 break;
1921             }
1922         }
1923
1924         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1925         /* fixme: add a warning if this user-id already exists */
1926         if( !*amail && !opt.allow_freeform_uid
1927             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1928             fail = 1;
1929             tty_printf(_("Please don't put the email address "
1930                           "into the real name or the comment\n") );
1931         }
1932
1933         for(;;) {
1934             /* TRANSLATORS: These are the allowed answers in
1935                lower and uppercase.  Below you will find the matching
1936                string which should be translated accordingly and the
1937                letter changed to match the one in the answer string.
1938                
1939                  n = Change name
1940                  c = Change comment
1941                  e = Change email
1942                  o = Okay (ready, continue)
1943                  q = Quit
1944              */
1945             const char *ansstr = _("NnCcEeOoQq");
1946
1947             if( strlen(ansstr) != 10 )
1948                 BUG();
1949             if( cpr_enabled() ) {
1950                 answer = xstrdup(ansstr+6);
1951                 answer[1] = 0;
1952             }
1953             else {
1954                 answer = cpr_get("keygen.userid.cmd", fail?
1955                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1956                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1957                 cpr_kill_prompt();
1958             }
1959             if( strlen(answer) > 1 )
1960                 ;
1961             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1962                 xfree(aname); aname = NULL;
1963                 break;
1964             }
1965             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1966                 xfree(acomment); acomment = NULL;
1967                 break;
1968             }
1969             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1970                 xfree(amail); amail = NULL;
1971                 break;
1972             }
1973             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1974                 if( fail ) {
1975                     tty_printf(_("Please correct the error first\n"));
1976                 }
1977                 else {
1978                     xfree(aname); aname = NULL;
1979                     xfree(acomment); acomment = NULL;
1980                     xfree(amail); amail = NULL;
1981                     break;
1982                 }
1983             }
1984             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1985                 xfree(aname); aname = NULL;
1986                 xfree(acomment); acomment = NULL;
1987                 xfree(amail); amail = NULL;
1988                 xfree(uid); uid = NULL;
1989                 break;
1990             }
1991             xfree(answer);
1992         }
1993         xfree(answer);
1994         if( !amail && !acomment && !amail )
1995             break;
1996         xfree(uid); uid = NULL;
1997     }
1998     if( uid ) {
1999         char *p = native_to_utf8( uid );
2000         xfree( uid );
2001         uid = p;
2002     }
2003     return uid;
2004 }
2005
2006
2007 /* FIXME: We need a way to cancel this prompt. */
2008 static DEK *
2009 do_ask_passphrase( STRING2KEY **ret_s2k )
2010 {
2011     DEK *dek = NULL;
2012     STRING2KEY *s2k;
2013     const char *errtext = NULL;
2014
2015     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
2016
2017     s2k = xmalloc_secure( sizeof *s2k );
2018     for(;;) {
2019         s2k->mode = opt.s2k_mode;
2020         s2k->hash_algo = S2K_DIGEST_ALGO;
2021         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
2022                                  errtext, NULL);
2023         if( !dek ) {
2024             errtext = N_("passphrase not correctly repeated; try again");
2025             tty_printf(_("%s.\n"), _(errtext));
2026         }
2027         else if( !dek->keylen ) {
2028             xfree(dek); dek = NULL;
2029             xfree(s2k); s2k = NULL;
2030             tty_printf(_(
2031             "You don't want a passphrase - this is probably a *bad* idea!\n"
2032             "I will do it anyway.  You can change your passphrase at any time,\n"
2033             "using this program with the option \"--edit-key\".\n\n"));
2034             break;
2035         }
2036         else
2037             break; /* okay */
2038     }
2039     *ret_s2k = s2k;
2040     return dek;
2041 }
2042
2043
2044 static int
2045 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
2046            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate,
2047            int is_subkey )
2048 {
2049   int rc=0;
2050
2051   if( !opt.batch )
2052     tty_printf(_(
2053 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2054 "some other action (type on the keyboard, move the mouse, utilize the\n"
2055 "disks) during the prime generation; this gives the random number\n"
2056 "generator a better chance to gain enough entropy.\n") );
2057
2058   if( algo == PUBKEY_ALGO_ELGAMAL_E )
2059     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
2060                  is_subkey);
2061   else if( algo == PUBKEY_ALGO_DSA )
2062     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
2063                  is_subkey);
2064   else if( algo == PUBKEY_ALGO_RSA )
2065     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate,
2066                  is_subkey);
2067   else
2068     BUG();
2069
2070   return rc;
2071 }
2072
2073
2074 /****************
2075  * Generate a new user id packet, or return NULL if canceled
2076  */
2077 PKT_user_id *
2078 generate_user_id()
2079 {
2080     PKT_user_id *uid;
2081     char *p;
2082     size_t n;
2083
2084     p = ask_user_id( 1 );
2085     if( !p )
2086         return NULL;
2087     n = strlen(p);
2088     uid = xmalloc_clear( sizeof *uid + n - 1 );
2089     uid->len = n;
2090     strcpy(uid->name, p);
2091     uid->ref = 1;
2092     return uid;
2093 }
2094
2095
2096 static void
2097 release_parameter_list( struct para_data_s *r )
2098 {
2099     struct para_data_s *r2;
2100
2101     for( ; r ; r = r2 ) {
2102         r2 = r->next;
2103         if( r->key == pPASSPHRASE_DEK )
2104             xfree( r->u.dek );
2105         else if( r->key == pPASSPHRASE_S2K )
2106             xfree( r->u.s2k );
2107
2108         xfree(r);
2109     }
2110 }
2111
2112 static struct para_data_s *
2113 get_parameter( struct para_data_s *para, enum para_name key )
2114 {
2115     struct para_data_s *r;
2116
2117     for( r = para; r && r->key != key; r = r->next )
2118         ;
2119     return r;
2120 }
2121
2122 static const char *
2123 get_parameter_value( struct para_data_s *para, enum para_name key )
2124 {
2125     struct para_data_s *r = get_parameter( para, key );
2126     return (r && *r->u.value)? r->u.value : NULL;
2127 }
2128
2129 static int
2130 get_parameter_algo( struct para_data_s *para, enum para_name key )
2131 {
2132     int i;
2133     struct para_data_s *r = get_parameter( para, key );
2134     if( !r )
2135         return -1;
2136     if( digitp( r->u.value ) )
2137         i = atoi( r->u.value );
2138     else
2139         i = string_to_pubkey_algo( r->u.value );
2140     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2141       i = 0; /* we don't want to allow generation of these algorithms */
2142     return i;
2143 }
2144
2145 /* 
2146  * parse the usage parameter and set the keyflags.  Return true on error.
2147  */
2148 static int
2149 parse_parameter_usage (const char *fname,
2150                        struct para_data_s *para, enum para_name key)
2151 {
2152     struct para_data_s *r = get_parameter( para, key );
2153     char *p, *pn;
2154     unsigned int use;
2155
2156     if( !r )
2157         return 0; /* none (this is an optional parameter)*/
2158     
2159     use = 0;
2160     pn = r->u.value;
2161     while ( (p = strsep (&pn, " \t,")) ) {
2162         if ( !*p)
2163             ;
2164         else if ( !ascii_strcasecmp (p, "sign") )
2165             use |= PUBKEY_USAGE_SIG;
2166         else if ( !ascii_strcasecmp (p, "encrypt") )
2167             use |= PUBKEY_USAGE_ENC;
2168         else if ( !ascii_strcasecmp (p, "auth") )
2169             use |= PUBKEY_USAGE_AUTH;
2170         else {
2171             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2172             return -1; /* error */
2173         }
2174     }
2175     r->u.usage = use;
2176     return 1;
2177 }
2178
2179 static int
2180 parse_revocation_key (const char *fname,
2181                       struct para_data_s *para, enum para_name key)
2182 {
2183   struct para_data_s *r = get_parameter( para, key );
2184   struct revocation_key revkey;
2185   char *pn;
2186   int i;
2187
2188   if( !r )
2189     return 0; /* none (this is an optional parameter) */
2190
2191   pn = r->u.value;
2192
2193   revkey.class=0x80;
2194   revkey.algid=atoi(pn);
2195   if(!revkey.algid)
2196     goto fail;
2197
2198   /* Skip to the fpr */
2199   while(*pn && *pn!=':')
2200     pn++;
2201
2202   if(*pn!=':')
2203     goto fail;
2204
2205   pn++;
2206
2207   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2208     {
2209       int c=hextobyte(pn);
2210       if(c==-1)
2211         goto fail;
2212
2213       revkey.fpr[i]=c;
2214     }
2215
2216   /* skip to the tag */
2217   while(*pn && *pn!='s' && *pn!='S')
2218     pn++;
2219
2220   if(ascii_strcasecmp(pn,"sensitive")==0)
2221     revkey.class|=0x40;
2222
2223   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2224
2225   return 0;
2226
2227   fail:
2228   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2229   return -1; /* error */
2230 }
2231
2232
2233 static u32
2234 get_parameter_u32( struct para_data_s *para, enum para_name key )
2235 {
2236     struct para_data_s *r = get_parameter( para, key );
2237
2238     if( !r )
2239         return 0;
2240     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2241         return r->u.expire;
2242     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2243         return r->u.usage;
2244
2245     return (unsigned int)strtoul( r->u.value, NULL, 10 );
2246 }
2247
2248 static unsigned int
2249 get_parameter_uint( struct para_data_s *para, enum para_name key )
2250 {
2251     return get_parameter_u32( para, key );
2252 }
2253
2254 static DEK *
2255 get_parameter_dek( struct para_data_s *para, enum para_name key )
2256 {
2257     struct para_data_s *r = get_parameter( para, key );
2258     return r? r->u.dek : NULL;
2259 }
2260
2261 static STRING2KEY *
2262 get_parameter_s2k( struct para_data_s *para, enum para_name key )
2263 {
2264     struct para_data_s *r = get_parameter( para, key );
2265     return r? r->u.s2k : NULL;
2266 }
2267
2268 static struct revocation_key *
2269 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2270 {
2271     struct para_data_s *r = get_parameter( para, key );
2272     return r? &r->u.revkey : NULL;
2273 }
2274
2275 static int
2276 proc_parameter_file( struct para_data_s *para, const char *fname,
2277                      struct output_control_s *outctrl, int card )
2278 {
2279   struct para_data_s *r;
2280   const char *s1, *s2, *s3;
2281   size_t n;
2282   char *p;
2283   int have_user_id=0,err,algo;
2284
2285   /* Check that we have all required parameters. */
2286   r = get_parameter( para, pKEYTYPE );
2287   if(r)
2288     {
2289       algo=get_parameter_algo(para,pKEYTYPE);
2290       if(check_pubkey_algo2(algo,PUBKEY_USAGE_SIG))
2291         {
2292           log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2293           return -1;
2294         }
2295     }
2296   else
2297     {
2298       log_error("%s: no Key-Type specified\n",fname);
2299       return -1;
2300     }
2301
2302   err=parse_parameter_usage (fname, para, pKEYUSAGE);
2303   if(err==0)
2304     {
2305       /* Default to algo capabilities if key-usage is not provided */
2306       r=xmalloc_clear(sizeof(*r));
2307       r->key=pKEYUSAGE;
2308       r->u.usage=openpgp_pk_algo_usage(algo);
2309       r->next=para;
2310       para=r;
2311     }
2312   else if(err==-1)
2313     return -1;
2314
2315   r = get_parameter( para, pSUBKEYTYPE );
2316   if(r)
2317     {
2318       algo=get_parameter_algo( para, pSUBKEYTYPE);
2319       if(check_pubkey_algo(algo))
2320         {
2321           log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2322           return -1;
2323         }
2324
2325       err=parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2326       if(err==0)
2327         {
2328           /* Default to algo capabilities if subkey-usage is not
2329              provided */
2330           r=xmalloc_clear(sizeof(*r));
2331           r->key=pSUBKEYUSAGE;
2332           r->u.usage=openpgp_pk_algo_usage(algo);
2333           r->next=para;
2334           para=r;
2335         }
2336       else if(err==-1)
2337         return -1;
2338     }
2339
2340   if( get_parameter_value( para, pUSERID ) )
2341     have_user_id=1;
2342   else
2343     {
2344       /* create the formatted user ID */
2345       s1 = get_parameter_value( para, pNAMEREAL );
2346       s2 = get_parameter_value( para, pNAMECOMMENT );
2347       s3 = get_parameter_value( para, pNAMEEMAIL );
2348       if( s1 || s2 || s3 )
2349         {
2350           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2351           r = xmalloc_clear( sizeof *r + n + 20 );
2352           r->key = pUSERID;
2353           p = r->u.value;
2354           if( s1 )
2355             p = stpcpy(p, s1 );
2356           if( s2 )
2357             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2358           if( s3 )
2359             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2360           r->next = para;
2361           para = r;
2362           have_user_id=1;
2363         }
2364     }
2365
2366   if(!have_user_id)
2367     {
2368       log_error("%s: no User-ID specified\n",fname);
2369       return -1;
2370     }
2371
2372   /* Set preferences, if any. */
2373   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2374
2375   /* Set revoker, if any. */
2376   if (parse_revocation_key (fname, para, pREVOKER))
2377     return -1;
2378
2379   /* make DEK and S2K from the Passphrase */
2380   r = get_parameter( para, pPASSPHRASE );
2381   if( r && *r->u.value ) {
2382     /* we have a plain text passphrase - create a DEK from it.
2383      * It is a little bit ridiculous to keep it ih secure memory
2384      * but becuase we do this alwasy, why not here */
2385     STRING2KEY *s2k;
2386     DEK *dek;
2387
2388     s2k = xmalloc_secure( sizeof *s2k );
2389     s2k->mode = opt.s2k_mode;
2390     s2k->hash_algo = S2K_DIGEST_ALGO;
2391     set_next_passphrase( r->u.value );
2392     dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2393                              NULL, NULL);
2394     set_next_passphrase( NULL );
2395     assert( dek );
2396     memset( r->u.value, 0, strlen(r->u.value) );
2397
2398     r = xmalloc_clear( sizeof *r );
2399     r->key = pPASSPHRASE_S2K;
2400     r->u.s2k = s2k;
2401     r->next = para;
2402     para = r;
2403     r = xmalloc_clear( sizeof *r );
2404     r->key = pPASSPHRASE_DEK;
2405     r->u.dek = dek;
2406     r->next = para;
2407     para = r;
2408   }
2409
2410   /* make KEYEXPIRE from Expire-Date */
2411   r = get_parameter( para, pEXPIREDATE );
2412   if( r && *r->u.value )
2413     {
2414       u32 seconds;
2415
2416       seconds = parse_expire_string( r->u.value );
2417       if( seconds == (u32)-1 )
2418         {
2419           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2420           return -1;
2421         }
2422       r->u.expire = seconds;
2423       r->key = pKEYEXPIRE;  /* change hat entry */
2424       /* also set it for the subkey */
2425       r = xmalloc_clear( sizeof *r + 20 );
2426       r->key = pSUBKEYEXPIRE;
2427       r->u.expire = seconds;
2428       r->next = para;
2429       para = r;
2430     }
2431
2432   if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2433     log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2434     return -1;
2435   }
2436
2437   do_generate_keypair( para, outctrl, card );
2438   return 0;
2439 }
2440
2441
2442 /****************
2443  * Kludge to allow non interactive key generation controlled
2444  * by a parameter file.
2445  * Note, that string parameters are expected to be in UTF-8
2446  */
2447 static void
2448 read_parameter_file( const char *fname )
2449 {
2450     static struct { const char *name;
2451                     enum para_name key;
2452     } keywords[] = {
2453         { "Key-Type",       pKEYTYPE},
2454         { "Key-Length",     pKEYLENGTH },
2455         { "Key-Usage",      pKEYUSAGE },
2456         { "Subkey-Type",    pSUBKEYTYPE },
2457         { "Subkey-Length",  pSUBKEYLENGTH },
2458         { "Subkey-Usage",   pSUBKEYUSAGE },
2459         { "Name-Real",      pNAMEREAL },
2460         { "Name-Email",     pNAMEEMAIL },
2461         { "Name-Comment",   pNAMECOMMENT },
2462         { "Expire-Date",    pEXPIREDATE },
2463         { "Passphrase",     pPASSPHRASE },
2464         { "Preferences",    pPREFERENCES },
2465         { "Revoker",        pREVOKER },
2466         { "Handle",         pHANDLE },
2467         { NULL, 0 }
2468     };
2469     IOBUF fp;
2470     byte *line;
2471     unsigned int maxlen, nline;
2472     char *p;
2473     int lnr;
2474     const char *err = NULL;
2475     struct para_data_s *para, *r;
2476     int i;
2477     struct output_control_s outctrl;
2478
2479     memset( &outctrl, 0, sizeof( outctrl ) );
2480
2481     if( !fname || !*fname)
2482       fname = "-";
2483
2484     fp = iobuf_open (fname);
2485     if (fp && is_secured_file (iobuf_get_fd (fp)))
2486       {
2487         iobuf_close (fp);
2488         fp = NULL;
2489         errno = EPERM;
2490       }
2491     if (!fp) {
2492       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2493       return;
2494     }
2495     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2496
2497     lnr = 0;
2498     err = NULL;
2499     para = NULL;
2500     maxlen = 1024;
2501     line = NULL;
2502     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2503         char *keyword, *value;
2504
2505         lnr++;
2506         if( !maxlen ) {
2507             err = "line too long";
2508             break;
2509         }
2510         for( p = line; isspace(*(byte*)p); p++ )
2511             ;
2512         if( !*p || *p == '#' )
2513             continue;
2514         keyword = p;
2515         if( *keyword == '%' ) {
2516             for( ; !isspace(*(byte*)p); p++ )
2517                 ;
2518             if( *p )
2519                 *p++ = 0;
2520             for( ; isspace(*(byte*)p); p++ )
2521                 ;
2522             value = p;
2523             trim_trailing_ws( value, strlen(value) );
2524             if( !ascii_strcasecmp( keyword, "%echo" ) )
2525                 log_info("%s\n", value );
2526             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2527                 outctrl.dryrun = 1;
2528             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2529                 outctrl.lnr = lnr;
2530                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2531                   print_status_key_not_created 
2532                     (get_parameter_value (para, pHANDLE));
2533                 release_parameter_list( para );
2534                 para = NULL;
2535             }
2536             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2537                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2538                     ; /* still the same file - ignore it */
2539                 else {
2540                     xfree( outctrl.pub.newfname );
2541                     outctrl.pub.newfname = xstrdup( value );
2542                     outctrl.use_files = 1;
2543                 }
2544             }
2545             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2546                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2547                     ; /* still the same file - ignore it */
2548                 else {
2549                    xfree( outctrl.sec.newfname );
2550                    outctrl.sec.newfname = xstrdup( value );
2551                    outctrl.use_files = 1;
2552                 }
2553             }
2554             else
2555                 log_info("skipping control `%s' (%s)\n", keyword, value );
2556
2557
2558             continue;
2559         }
2560
2561
2562         if( !(p = strchr( p, ':' )) || p == keyword ) {
2563             err = "missing colon";
2564             break;
2565         }
2566         if( *p )
2567             *p++ = 0;
2568         for( ; isspace(*(byte*)p); p++ )
2569             ;
2570         if( !*p ) {
2571             err = "missing argument";
2572             break;
2573         }
2574         value = p;
2575         trim_trailing_ws( value, strlen(value) );
2576
2577         for(i=0; keywords[i].name; i++ ) {
2578             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2579                 break;
2580         }
2581         if( !keywords[i].name ) {
2582             err = "unknown keyword";
2583             break;
2584         }
2585         if( keywords[i].key != pKEYTYPE && !para ) {
2586             err = "parameter block does not start with \"Key-Type\"";
2587             break;
2588         }
2589
2590         if( keywords[i].key == pKEYTYPE && para ) {
2591             outctrl.lnr = lnr;
2592             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2593               print_status_key_not_created
2594                 (get_parameter_value (para, pHANDLE));
2595             release_parameter_list( para );
2596             para = NULL;
2597         }
2598         else {
2599             for( r = para; r; r = r->next ) {
2600                 if( r->key == keywords[i].key )
2601                     break;
2602             }
2603             if( r ) {
2604                 err = "duplicate keyword";
2605                 break;
2606             }
2607         }
2608         r = xmalloc_clear( sizeof *r + strlen( value ) );
2609         r->lnr = lnr;
2610         r->key = keywords[i].key;
2611         strcpy( r->u.value, value );
2612         r->next = para;
2613         para = r;
2614     }
2615     if( err )
2616         log_error("%s:%d: %s\n", fname, lnr, err );
2617     else if( iobuf_error (fp) ) {
2618         log_error("%s:%d: read error\n", fname, lnr);
2619     }
2620     else if( para ) {
2621         outctrl.lnr = lnr;
2622         if (proc_parameter_file( para, fname, &outctrl, 0 ))
2623           print_status_key_not_created (get_parameter_value (para, pHANDLE));
2624     }
2625
2626     if( outctrl.use_files ) { /* close open streams */
2627         iobuf_close( outctrl.pub.stream );
2628         iobuf_close( outctrl.sec.stream );
2629
2630         /* Must invalidate that ugly cache to actually close it.  */
2631         if (outctrl.pub.fname)
2632           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
2633         if (outctrl.sec.fname)
2634           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
2635
2636         xfree( outctrl.pub.fname );
2637         xfree( outctrl.pub.newfname );
2638         xfree( outctrl.sec.fname );
2639         xfree( outctrl.sec.newfname );
2640     }
2641
2642     release_parameter_list( para );
2643     iobuf_close (fp);
2644 }
2645
2646
2647 /*
2648  * Generate a keypair (fname is only used in batch mode) If
2649  * CARD_SERIALNO is not NULL the fucntion will create the keys on an
2650  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
2651  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
2652  * generate in software, imported to the card and a backup file
2653  * written to directory given by this argument .
2654  */
2655 void
2656 generate_keypair (const char *fname, const char *card_serialno, 
2657                   const char *backup_encryption_dir)
2658 {
2659   unsigned int nbits;
2660   char *uid = NULL;
2661   DEK *dek;
2662   STRING2KEY *s2k;
2663   int algo;
2664   unsigned int use;
2665   int both = 0;
2666   u32 expire;
2667   struct para_data_s *para = NULL;
2668   struct para_data_s *r;
2669   struct output_control_s outctrl;
2670   
2671   memset( &outctrl, 0, sizeof( outctrl ) );
2672   
2673   if (opt.batch && card_serialno)
2674     {
2675       /* We don't yet support unattended key generation. */
2676       log_error (_("can't do this in batch mode\n"));
2677       return;
2678     }
2679   
2680   if (opt.batch)
2681     {
2682       read_parameter_file( fname );
2683       return;
2684     }
2685
2686   if (card_serialno)
2687     {
2688 #ifdef ENABLE_CARD_SUPPORT
2689       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2690       r->key = pSERIALNO;
2691       strcpy( r->u.value, card_serialno);
2692       r->next = para;
2693       para = r;
2694        
2695       algo = PUBKEY_ALGO_RSA;
2696        
2697       r = xcalloc (1, sizeof *r + 20 );
2698       r->key = pKEYTYPE;
2699       sprintf( r->u.value, "%d", algo );
2700       r->next = para;
2701       para = r;
2702       r = xcalloc (1, sizeof *r + 20 );
2703       r->key = pKEYUSAGE;
2704       strcpy (r->u.value, "sign");
2705       r->next = para;
2706       para = r;
2707        
2708       r = xcalloc (1, sizeof *r + 20 );
2709       r->key = pSUBKEYTYPE;
2710       sprintf( r->u.value, "%d", algo );
2711       r->next = para;
2712       para = r;
2713       r = xcalloc (1, sizeof *r + 20 );
2714       r->key = pSUBKEYUSAGE;
2715       strcpy (r->u.value, "encrypt");
2716       r->next = para;
2717       para = r;
2718        
2719       r = xcalloc (1, sizeof *r + 20 );
2720       r->key = pAUTHKEYTYPE;
2721       sprintf( r->u.value, "%d", algo );
2722       r->next = para;
2723       para = r;
2724
2725       if (backup_encryption_dir)
2726         {
2727           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
2728           r->key = pBACKUPENCDIR;
2729           strcpy (r->u.value, backup_encryption_dir);
2730           r->next = para;
2731           para = r;
2732         }
2733 #endif /*ENABLE_CARD_SUPPORT*/
2734     }
2735   else
2736     {
2737       algo = ask_algo( 0, &use );
2738       if( !algo )
2739         { /* default: DSA with ElG subkey of the specified size */
2740           both = 1;
2741           r = xmalloc_clear( sizeof *r + 20 );
2742           r->key = pKEYTYPE;
2743           sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2744           r->next = para;
2745           para = r;
2746           tty_printf(_("DSA keypair will have %u bits.\n"),1024);
2747           r = xmalloc_clear( sizeof *r + 20 );
2748           r->key = pKEYLENGTH;
2749           strcpy( r->u.value, "1024" );
2750           r->next = para;
2751           para = r;
2752           r = xmalloc_clear( sizeof *r + 20 );
2753           r->key = pKEYUSAGE;
2754           strcpy( r->u.value, "sign" );
2755           r->next = para;
2756           para = r;
2757            
2758           algo = PUBKEY_ALGO_ELGAMAL_E;
2759           r = xmalloc_clear( sizeof *r + 20 );
2760           r->key = pSUBKEYTYPE;
2761           sprintf( r->u.value, "%d", algo );
2762           r->next = para;
2763           para = r;
2764           r = xmalloc_clear( sizeof *r + 20 );
2765           r->key = pSUBKEYUSAGE;
2766           strcpy( r->u.value, "encrypt" );
2767           r->next = para;
2768           para = r;
2769         }
2770       else 
2771         {
2772           r = xmalloc_clear( sizeof *r + 20 );
2773           r->key = pKEYTYPE;
2774           sprintf( r->u.value, "%d", algo );
2775           r->next = para;
2776           para = r;
2777            
2778           if (use)
2779             {
2780               r = xmalloc_clear( sizeof *r + 25 );
2781               r->key = pKEYUSAGE;
2782               sprintf( r->u.value, "%s%s%s",
2783                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
2784                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
2785                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
2786               r->next = para;
2787               para = r;
2788             }
2789            
2790         }
2791        
2792       nbits = ask_keysize( algo );
2793       r = xmalloc_clear( sizeof *r + 20 );
2794       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2795       sprintf( r->u.value, "%u", nbits);
2796       r->next = para;
2797       para = r;
2798     }
2799    
2800   expire = ask_expire_interval(0,NULL);
2801   r = xmalloc_clear( sizeof *r + 20 );
2802   r->key = pKEYEXPIRE;
2803   r->u.expire = expire;
2804   r->next = para;
2805   para = r;
2806   r = xmalloc_clear( sizeof *r + 20 );
2807   r->key = pSUBKEYEXPIRE;
2808   r->u.expire = expire;
2809   r->next = para;
2810   para = r;
2811
2812   uid = ask_user_id(0);
2813   if( !uid ) 
2814     {
2815       log_error(_("Key generation canceled.\n"));
2816       release_parameter_list( para );
2817       return;
2818     }
2819   r = xmalloc_clear( sizeof *r + strlen(uid) );
2820   r->key = pUSERID;
2821   strcpy( r->u.value, uid );
2822   r->next = para;
2823   para = r;
2824     
2825   dek = card_serialno? NULL : do_ask_passphrase( &s2k );
2826   if( dek )
2827     {
2828       r = xmalloc_clear( sizeof *r );
2829       r->key = pPASSPHRASE_DEK;
2830       r->u.dek = dek;
2831       r->next = para;
2832       para = r;
2833       r = xmalloc_clear( sizeof *r );
2834       r->key = pPASSPHRASE_S2K;
2835       r->u.s2k = s2k;
2836       r->next = para;
2837       para = r;
2838     }
2839     
2840   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
2841   release_parameter_list( para );
2842 }
2843
2844
2845 #ifdef ENABLE_CARD_SUPPORT
2846 /* Generate a raw key and return it as a secret key packet.  The
2847    function will ask for the passphrase and return a protected as well
2848    as an unprotected copy of a new secret key packet.  0 is returned
2849    on success and the caller must then free the returned values.  */
2850 static int
2851 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
2852                   PKT_secret_key **r_sk_unprotected,
2853                   PKT_secret_key **r_sk_protected)
2854 {
2855   int rc;
2856   DEK *dek = NULL;
2857   STRING2KEY *s2k = NULL;
2858   PKT_secret_key *sk = NULL;
2859   int i;
2860   size_t nskey, npkey;
2861
2862   npkey = pubkey_get_npkey (algo);
2863   nskey = pubkey_get_nskey (algo);
2864   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
2865
2866   if (nbits < 512)
2867     {
2868       nbits = 512;
2869       log_info (_("keysize invalid; using %u bits\n"), nbits );
2870     }
2871
2872   if ((nbits % 32)) 
2873     {
2874       nbits = ((nbits + 31) / 32) * 32;
2875       log_info(_("keysize rounded up to %u bits\n"), nbits );
2876     }
2877
2878   dek = do_ask_passphrase (&s2k);
2879
2880   sk = xmalloc_clear (sizeof *sk);
2881   sk->timestamp = created_at;
2882   sk->version = 4;
2883   sk->pubkey_algo = algo;
2884
2885   if ( !is_RSA (algo) )
2886     {
2887       log_error ("only RSA is supported for offline generated keys\n");
2888       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2889       goto leave;
2890     }
2891   rc = gcry_sexp_build (&s_parms, NULL,
2892                         "(genkey(rsa(nbits %d)))",
2893                         (int)nbits);
2894   if (rc)
2895     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
2896   rc = gcry_pk_genkey (&s_key, s_parms);
2897   gcry_sexp_release (s_parms);
2898   if (rc)
2899     {
2900       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
2901       goto leave;
2902     }
2903   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
2904   gcry_sexp_release (s_key);
2905   if (rc) 
2906     {
2907       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
2908       goto leave;
2909     }
2910   
2911   for (i=npkey; i < nskey; i++)
2912     sk->csum += checksum_mpi (sk->skey[i]);
2913
2914   if (r_sk_unprotected) 
2915     *r_sk_unprotected = copy_secret_key (NULL, sk);
2916
2917   rc = genhelp_protect (dek, s2k, sk);
2918   if (rc)
2919     goto leave;
2920
2921   if (r_sk_protected)
2922     {
2923       *r_sk_protected = sk;
2924       sk = NULL;
2925     }
2926
2927  leave:
2928   if (sk)
2929     free_secret_key (sk);
2930   xfree (dek);
2931   xfree (s2k);
2932   return rc;
2933 }
2934 #endif /* ENABLE_CARD_SUPPORT */
2935
2936 /* Create and delete a dummy packet to start off a list of kbnodes. */
2937 static void
2938 start_tree(KBNODE *tree)
2939 {
2940   PACKET *pkt;
2941
2942   pkt=xmalloc_clear(sizeof(*pkt));
2943   pkt->pkttype=PKT_NONE;
2944   *tree=new_kbnode(pkt);
2945   delete_kbnode(*tree);
2946 }
2947
2948 static void
2949 do_generate_keypair( struct para_data_s *para,
2950                      struct output_control_s *outctrl, int card )
2951 {
2952     KBNODE pub_root = NULL;
2953     KBNODE sec_root = NULL;
2954     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
2955     const char *s;
2956     struct revocation_key *revkey;
2957     int rc;
2958     int did_sub = 0;
2959
2960     if( outctrl->dryrun )
2961       {
2962         log_info("dry-run mode - key generation skipped\n");
2963         return;
2964       }
2965
2966     if( outctrl->use_files ) {
2967         if( outctrl->pub.newfname ) {
2968             iobuf_close(outctrl->pub.stream);
2969             outctrl->pub.stream = NULL;
2970             if (outctrl->pub.fname)
2971               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
2972             xfree( outctrl->pub.fname );
2973             outctrl->pub.fname =  outctrl->pub.newfname;
2974             outctrl->pub.newfname = NULL;
2975
2976             if (is_secured_filename (outctrl->pub.fname) ) {
2977                 outctrl->pub.stream = NULL;
2978                 errno = EPERM;
2979             }
2980             else
2981                 outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
2982             if( !outctrl->pub.stream ) {
2983                 log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
2984                                                      strerror(errno) );
2985                 return;
2986             }
2987             if( opt.armor ) {
2988                 outctrl->pub.afx.what = 1;
2989                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
2990                                                     &outctrl->pub.afx );
2991             }
2992         }
2993         if( outctrl->sec.newfname ) {
2994             mode_t oldmask;
2995
2996             iobuf_close(outctrl->sec.stream);
2997             outctrl->sec.stream = NULL;
2998             if (outctrl->sec.fname)
2999               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
3000             xfree( outctrl->sec.fname );
3001             outctrl->sec.fname =  outctrl->sec.newfname;
3002             outctrl->sec.newfname = NULL;
3003
3004             oldmask = umask (077);
3005             if (is_secured_filename (outctrl->sec.fname) ) {
3006                 outctrl->sec.stream = NULL;
3007                 errno = EPERM;
3008             }
3009             else
3010                 outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
3011             umask (oldmask);
3012             if( !outctrl->sec.stream ) {
3013                 log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
3014                                                      strerror(errno) );
3015                 return;
3016             }
3017             if( opt.armor ) {
3018                 outctrl->sec.afx.what = 5;
3019                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
3020                                                     &outctrl->sec.afx );
3021             }
3022         }
3023         assert( outctrl->pub.stream );
3024         assert( outctrl->sec.stream );
3025         if( opt.verbose ) {
3026             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
3027             if (card)
3028               log_info (_("writing secret key stub to `%s'\n"),
3029                         outctrl->sec.fname);
3030             else
3031               log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
3032         }
3033     }
3034
3035
3036     /* we create the packets as a tree of kbnodes. Because the
3037      * structure we create is known in advance we simply generate a
3038      * linked list.  The first packet is a dummy packet which we flag
3039      * as deleted.  The very first packet must always be a KEY packet.
3040      */
3041     
3042     start_tree(&pub_root);
3043     start_tree(&sec_root);
3044
3045     if (!card)
3046       {
3047         rc = do_create( get_parameter_algo( para, pKEYTYPE ),
3048                         get_parameter_uint( para, pKEYLENGTH ),
3049                         pub_root, sec_root,
3050                         get_parameter_dek( para, pPASSPHRASE_DEK ),
3051                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
3052                         &pri_sk,
3053                         get_parameter_u32( para, pKEYEXPIRE ), 0 );
3054       }
3055     else
3056       {
3057         rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root,
3058                            get_parameter_u32 (para, pKEYEXPIRE), para);
3059         if (!rc)
3060           {
3061             pri_sk = sec_root->next->pkt->pkt.secret_key;
3062             assert (pri_sk);
3063           }
3064       }
3065
3066     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
3067       {
3068         rc=write_direct_sig(pub_root,pub_root,pri_sk,revkey);
3069         if(!rc)
3070           write_direct_sig(sec_root,pub_root,pri_sk,revkey);
3071       }
3072
3073     if( !rc && (s=get_parameter_value(para, pUSERID)) )
3074       {
3075         write_uid(pub_root, s );
3076         if( !rc )
3077           write_uid(sec_root, s );
3078
3079         if( !rc )
3080           rc = write_selfsigs(sec_root, pub_root, pri_sk,
3081                               get_parameter_uint (para, pKEYUSAGE));
3082       }
3083
3084     /* Write the auth key to the card before the encryption key.  This
3085        is a partial workaround for a PGP bug (as of this writing, all
3086        versions including 8.1), that causes it to try and encrypt to
3087        the most recent subkey regardless of whether that subkey is
3088        actually an encryption type.  In this case, the auth key is an
3089        RSA key so it succeeds. */
3090
3091     if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
3092       {
3093         rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root,
3094                            get_parameter_u32 (para, pKEYEXPIRE), para);
3095         
3096         if (!rc)
3097           rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
3098         if (!rc)
3099           rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk, PUBKEY_USAGE_AUTH);
3100       }
3101
3102     if( !rc && get_parameter( para, pSUBKEYTYPE ) )
3103       {
3104         if (!card)
3105           {
3106             rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
3107                             get_parameter_uint( para, pSUBKEYLENGTH ),
3108                             pub_root, sec_root,
3109                             get_parameter_dek( para, pPASSPHRASE_DEK ),
3110                             get_parameter_s2k( para, pPASSPHRASE_S2K ),
3111                             &sub_sk,
3112                             get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
3113           }
3114         else
3115           {
3116             if ((s = get_parameter_value (para, pBACKUPENCDIR)))
3117               {
3118                 /* A backup of the encryption key has been requested.
3119                    Generate the key i software and import it then to
3120                    the card.  Write a backup file. */
3121                 rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
3122                                                pub_root, sec_root,
3123                                                get_parameter_u32 (para,
3124                                                                   pKEYEXPIRE),
3125                                                para, s);
3126               }
3127             else
3128               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
3129                                  get_parameter_u32 (para, pKEYEXPIRE), para);
3130           }
3131
3132         if( !rc )
3133           rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
3134                                 get_parameter_uint (para, pSUBKEYUSAGE));
3135         if( !rc )
3136           rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
3137                                 get_parameter_uint (para, pSUBKEYUSAGE));
3138         did_sub = 1;
3139       }
3140
3141     if( !rc && outctrl->use_files ) { /* direct write to specified files */
3142         rc = write_keyblock( outctrl->pub.stream, pub_root );
3143         if( rc )
3144             log_error("can't write public key: %s\n", g10_errstr(rc) );
3145         if( !rc ) {
3146             rc = write_keyblock( outctrl->sec.stream, sec_root );
3147             if( rc )
3148                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
3149         }
3150
3151     }
3152     else if( !rc ) { /* write to the standard keyrings */
3153         KEYDB_HANDLE pub_hd = keydb_new (0);
3154         KEYDB_HANDLE sec_hd = keydb_new (1);
3155
3156         /* FIXME: we may have to create the keyring first */
3157         rc = keydb_locate_writable (pub_hd, NULL);
3158         if (rc) 
3159             log_error (_("no writable public keyring found: %s\n"),
3160                        g10_errstr (rc));
3161
3162         if (!rc) {  
3163             rc = keydb_locate_writable (sec_hd, NULL);
3164             if (rc) 
3165                 log_error (_("no writable secret keyring found: %s\n"),
3166                            g10_errstr (rc));
3167         }
3168
3169         if (!rc && opt.verbose) {
3170             log_info(_("writing public key to `%s'\n"),
3171                      keydb_get_resource_name (pub_hd));
3172             if (card)
3173               log_info (_("writing secret key stub to `%s'\n"),
3174                         keydb_get_resource_name (sec_hd));
3175             else
3176               log_info(_("writing secret key to `%s'\n"),
3177                        keydb_get_resource_name (sec_hd));
3178         }
3179
3180         if (!rc) {
3181             rc = keydb_insert_keyblock (pub_hd, pub_root);
3182             if (rc)
3183                 log_error (_("error writing public keyring `%s': %s\n"),
3184                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
3185         }
3186
3187         if (!rc) {
3188             rc = keydb_insert_keyblock (sec_hd, sec_root);
3189             if (rc)
3190                 log_error (_("error writing secret keyring `%s': %s\n"),
3191                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
3192         }
3193
3194         keydb_release (pub_hd);
3195         keydb_release (sec_hd);
3196
3197         if (!rc) {
3198             int no_enc_rsa =
3199                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
3200                 && get_parameter_uint( para, pKEYUSAGE )
3201                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
3202             PKT_public_key *pk = find_kbnode (pub_root, 
3203                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3204
3205             keyid_from_pk(pk,pk->main_keyid);
3206             register_trusted_keyid(pk->main_keyid);
3207
3208             update_ownertrust (pk,
3209                                ((get_ownertrust (pk) & ~TRUST_MASK)
3210                                 | TRUST_ULTIMATE ));
3211
3212             if (!opt.batch) {
3213                 tty_printf(_("public and secret key created and signed.\n") );
3214                 tty_printf("\n");
3215                 list_keyblock(pub_root,0,1,NULL);
3216             }
3217             
3218
3219             if( !opt.batch
3220                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
3221                      || no_enc_rsa )
3222                 && !get_parameter( para, pSUBKEYTYPE ) )
3223             {
3224                 tty_printf(_("Note that this key cannot be used for "
3225                              "encryption.  You may want to use\n"
3226                              "the command \"--edit-key\" to generate a "
3227                              "subkey for this purpose.\n") );
3228             }
3229         }
3230     }
3231
3232     if( rc ) {
3233         if( opt.batch )
3234             log_error("key generation failed: %s\n", g10_errstr(rc) );
3235         else
3236             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
3237         print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
3238     }
3239     else {
3240         PKT_public_key *pk = find_kbnode (pub_root, 
3241                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3242         print_status_key_created (did_sub? 'B':'P', pk,
3243                                   get_parameter_value (para, pHANDLE));
3244     }
3245     release_kbnode( pub_root );
3246     release_kbnode( sec_root );
3247
3248     if( pri_sk && !card) /* the unprotected  secret key unless we have a */
3249       free_secret_key(pri_sk); /* shallow copy in card mode. */
3250     if( sub_sk )
3251         free_secret_key(sub_sk);
3252 }
3253
3254
3255 /****************
3256  * add a new subkey to an existing key.
3257  * Returns true if a new key has been generated and put into the keyblocks.
3258  */
3259 int
3260 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
3261 {
3262     int okay=0, rc=0;
3263     KBNODE node;
3264     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3265     int algo;
3266     unsigned int use;
3267     u32 expire;
3268     unsigned nbits;
3269     char *passphrase = NULL;
3270     DEK *dek = NULL;
3271     STRING2KEY *s2k = NULL;
3272     u32 cur_time;
3273     int ask_pass = 0;
3274
3275     /* break out the primary secret key */
3276     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3277     if( !node ) {
3278         log_error("Oops; secret key not found anymore!\n");
3279         goto leave;
3280     }
3281
3282     /* make a copy of the sk to keep the protected one in the keyblock */
3283     pri_sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
3284
3285     cur_time = make_timestamp();
3286     if( pri_sk->timestamp > cur_time ) {
3287         ulong d = pri_sk->timestamp - cur_time;
3288         log_info( d==1 ? _("key has been created %lu second "
3289                            "in future (time warp or clock problem)\n")
3290                        : _("key has been created %lu seconds "
3291                            "in future (time warp or clock problem)\n"), d );
3292         if( !opt.ignore_time_conflict ) {
3293             rc = G10ERR_TIME_CONFLICT;
3294             goto leave;
3295         }
3296     }
3297
3298     if (pri_sk->version < 4) {
3299         log_info (_("NOTE: creating subkeys for v3 keys "
3300                     "is not OpenPGP compliant\n"));
3301         goto leave;
3302     }
3303
3304     if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001) {
3305         tty_printf(_("Secret parts of primary key are not available.\n"));
3306         rc = G10ERR_NO_SECKEY;
3307         goto leave;
3308     }
3309
3310
3311     /* Unprotect to get the passphrase.  */
3312     switch( is_secret_key_protected( pri_sk ) ) {
3313       case -1:
3314         rc = G10ERR_PUBKEY_ALGO;
3315         break;
3316       case 0:
3317         tty_printf(_("This key is not protected.\n"));
3318         break;
3319       case -2:
3320         tty_printf(_("Secret parts of primary key are stored on-card.\n"));
3321         ask_pass = 1;
3322         break;
3323       default:
3324         tty_printf(_("Key is protected.\n"));
3325         rc = check_secret_key( pri_sk, 0 );
3326         if( !rc )
3327             passphrase = get_last_passphrase();
3328         break;
3329     }
3330     if( rc )
3331         goto leave;
3332
3333     algo = ask_algo( 1, &use );
3334     assert(algo);
3335     nbits = ask_keysize( algo );
3336     expire = ask_expire_interval(0,NULL);
3337     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3338                                                   _("Really create? (y/N) ")))
3339         goto leave;
3340
3341     if (ask_pass)
3342         dek = do_ask_passphrase (&s2k);
3343     else if (passphrase) {
3344         s2k = xmalloc_secure( sizeof *s2k );
3345         s2k->mode = opt.s2k_mode;
3346         s2k->hash_algo = S2K_DIGEST_ALGO;
3347         set_next_passphrase( passphrase );
3348         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3349                                  NULL, NULL );
3350     }
3351
3352     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
3353                                       dek, s2k, &sub_sk, expire, 1 );
3354     if( !rc )
3355         rc = write_keybinding(pub_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3356     if( !rc )
3357         rc = write_keybinding(sec_keyblock, pub_keyblock, pri_sk, sub_sk, use);
3358     if( !rc ) {
3359         okay = 1;
3360         write_status_text (STATUS_KEY_CREATED, "S");
3361     }
3362
3363   leave:
3364     if( rc )
3365         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
3366     xfree( passphrase );
3367     xfree( dek );
3368     xfree( s2k );
3369     /* release the copy of the (now unprotected) secret keys */
3370     if( pri_sk )
3371         free_secret_key(pri_sk);
3372     if( sub_sk )
3373         free_secret_key(sub_sk);
3374     set_next_passphrase( NULL );
3375     return okay;
3376 }
3377
3378
3379 #ifdef ENABLE_CARD_SUPPORT
3380 /* Generate a subkey on a card. */
3381 int
3382 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3383                           int keyno, const char *serialno)
3384 {
3385   int okay=0, rc=0;
3386   KBNODE node;
3387   PKT_secret_key *pri_sk = NULL;
3388   int algo;
3389   unsigned int use;
3390   u32 expire;
3391   char *passphrase = NULL;
3392   u32 cur_time;
3393   struct para_data_s *para = NULL;
3394
3395   assert (keyno >= 1 && keyno <= 3);
3396
3397   para = xcalloc (1, sizeof *para + strlen (serialno) );
3398   para->key = pSERIALNO;
3399   strcpy (para->u.value, serialno);
3400
3401   /* Break out the primary secret key */
3402   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3403   if(!node)
3404     {
3405       log_error("Oops; secret key not found anymore!\n");
3406       goto leave;
3407     }
3408
3409   /* Make a copy of the sk to keep the protected one in the keyblock */
3410   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3411
3412   cur_time = make_timestamp();
3413   if (pri_sk->timestamp > cur_time)
3414     {
3415       ulong d = pri_sk->timestamp - cur_time;
3416       log_info (d==1 ? _("key has been created %lu second "
3417                          "in future (time warp or clock problem)\n")
3418                      : _("key has been created %lu seconds "
3419                          "in future (time warp or clock problem)\n"), d );
3420         if (!opt.ignore_time_conflict)
3421           {
3422             rc = G10ERR_TIME_CONFLICT;
3423             goto leave;
3424           }
3425     }
3426
3427   if (pri_sk->version < 4)
3428     {
3429       log_info (_("NOTE: creating subkeys for v3 keys "
3430                   "is not OpenPGP compliant\n"));
3431       goto leave;
3432     }
3433
3434   /* Unprotect to get the passphrase. */
3435   switch( is_secret_key_protected (pri_sk) )
3436     {
3437     case -1:
3438       rc = G10ERR_PUBKEY_ALGO;
3439       break;
3440     case 0:
3441       tty_printf("This key is not protected.\n");
3442       break;
3443     default:
3444       tty_printf("Key is protected.\n");
3445       rc = check_secret_key( pri_sk, 0 );
3446       if (!rc)
3447         passphrase = get_last_passphrase();
3448       break;
3449     }
3450   if (rc)
3451     goto leave;
3452
3453   algo = PUBKEY_ALGO_RSA;
3454   expire = ask_expire_interval (0,NULL);
3455   if (keyno == 1)
3456     use = PUBKEY_USAGE_SIG;
3457   else if (keyno == 2)
3458     use = PUBKEY_USAGE_ENC;
3459   else
3460     use = PUBKEY_USAGE_AUTH;
3461   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3462                                                _("Really create? (y/N) ")))
3463     goto leave;
3464
3465   if (passphrase)
3466     set_next_passphrase (passphrase);
3467   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock, expire, para);
3468   if (!rc)
3469     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, NULL, use);
3470   if (!rc)
3471     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, NULL, use);
3472   if (!rc)
3473     {
3474       okay = 1;
3475       write_status_text (STATUS_KEY_CREATED, "S");
3476     }
3477
3478  leave:
3479   if (rc)
3480     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3481   xfree (passphrase);
3482   /* Release the copy of the (now unprotected) secret keys. */
3483   if (pri_sk)
3484     free_secret_key (pri_sk);
3485   set_next_passphrase( NULL );
3486   release_parameter_list (para);
3487   return okay;
3488 }
3489 #endif /* !ENABLE_CARD_SUPPORT */
3490
3491
3492 /****************
3493  * Write a keyblock to an output stream
3494  */
3495 static int
3496 write_keyblock( IOBUF out, KBNODE node )
3497 {
3498   for( ; node ; node = node->next )
3499     {
3500       if(!is_deleted_kbnode(node))
3501         {
3502           int rc = build_packet( out, node->pkt );
3503           if( rc )
3504             {
3505               log_error("build_packet(%d) failed: %s\n",
3506                         node->pkt->pkttype, g10_errstr(rc) );
3507               return G10ERR_WRITE_FILE;
3508             }
3509         }
3510     }
3511
3512   return 0;
3513 }
3514
3515
3516 static int
3517 gen_card_key (int algo, int keyno, int is_primary,
3518               KBNODE pub_root, KBNODE sec_root,
3519               u32 expireval, struct para_data_s *para)
3520 {
3521 #ifdef ENABLE_CARD_SUPPORT
3522   int rc;
3523   const char *s;
3524   struct agent_card_genkey_s info;
3525   PACKET *pkt;
3526   PKT_secret_key *sk;
3527   PKT_public_key *pk;
3528
3529   assert (algo == PUBKEY_ALGO_RSA);
3530   
3531   /* Fixme: We don't have the serialnumber available, thus passing NULL. */
3532   rc = agent_scd_genkey (&info, keyno, 1, NULL);
3533 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3534 /*      { */
3535 /*        tty_printf ("\n"); */
3536 /*        log_error ("WARNING: key does already exists!\n"); */
3537 /*        tty_printf ("\n"); */
3538 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3539 /*                                    _("Replace existing key? "))) */
3540 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3541 /*      } */
3542
3543   if (rc)
3544     {
3545       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3546       return rc;
3547     }
3548   if ( !info.n || !info.e )
3549     {
3550       log_error ("communication error with SCD\n");
3551       mpi_free (info.n);
3552       mpi_free (info.e);
3553       return gpg_error (GPG_ERR_GENERAL);
3554     }
3555   
3556
3557   pk = xcalloc (1, sizeof *pk );
3558   sk = xcalloc (1, sizeof *sk );
3559   sk->timestamp = pk->timestamp = info.created_at;
3560   sk->version = pk->version = 4;
3561   if (expireval)
3562       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3563   sk->pubkey_algo = pk->pubkey_algo = algo;
3564   pk->pkey[0] = info.n;
3565   pk->pkey[1] = info.e; 
3566   sk->skey[0] = gcry_mpi_copy (pk->pkey[0]);
3567   sk->skey[1] = gcry_mpi_copy (pk->pkey[1]);
3568   sk->skey[2] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
3569   sk->is_protected = 1;
3570   sk->protect.s2k.mode = 1002;
3571   s = get_parameter_value (para, pSERIALNO);
3572   if (s)
3573     {
3574       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3575            sk->protect.ivlen++, s += 2)
3576         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3577     }
3578
3579   pkt = xcalloc (1,sizeof *pkt);
3580   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3581   pkt->pkt.public_key = pk;
3582   add_kbnode(pub_root, new_kbnode( pkt ));
3583
3584   pkt = xcalloc (1,sizeof *pkt);
3585   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3586   pkt->pkt.secret_key = sk;
3587   add_kbnode(sec_root, new_kbnode( pkt ));
3588
3589   return 0;
3590 #else
3591   return -1;
3592 #endif /*!ENABLE_CARD_SUPPORT*/
3593 }
3594
3595
3596
3597 static int
3598 gen_card_key_with_backup (int algo, int keyno, int is_primary,
3599                           KBNODE pub_root, KBNODE sec_root,
3600                           u32 expireval, struct para_data_s *para,
3601                           const char *backup_dir)
3602 {
3603 #ifdef ENABLE_CARD_SUPPORT
3604   int rc;
3605   const char *s;
3606   PACKET *pkt;
3607   PKT_secret_key *sk, *sk_unprotected, *sk_protected;
3608   PKT_public_key *pk;
3609   size_t n;
3610   int i;
3611
3612   rc = generate_raw_key (algo, 1024, make_timestamp (),
3613                          &sk_unprotected, &sk_protected);
3614   if (rc)
3615     return rc;
3616
3617   /* First, store the key to the card. */
3618   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
3619   if (rc)
3620     {
3621       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
3622       free_secret_key (sk_unprotected);
3623       free_secret_key (sk_protected);
3624       return rc;
3625     }
3626
3627   /* Get rid of the secret key parameters and store the serial numer. */
3628   sk = sk_unprotected;
3629   n = pubkey_get_nskey (sk->pubkey_algo);
3630   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
3631     {
3632       mpi_free (sk->skey[i]);
3633       sk->skey[i] = NULL;
3634     }
3635   i = pubkey_get_npkey (sk->pubkey_algo);
3636   sk->skey[i] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);