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