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