* sign.c (sign_file): Do not push textmode filter onto an unopened IOBUF
[gnupg.git] / g10 / keygen.c
1 /* keygen.c - generate a key pair
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *                                               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 "util.h"
30 #include "main.h"
31 #include "packet.h"
32 #include "cipher.h"
33 #include "ttyio.h"
34 #include "options.h"
35 #include "keydb.h"
36 #include "trustdb.h"
37 #include "status.h"
38 #include "i18n.h"
39
40 #define MAX_PREFS 30 
41
42 enum para_name {
43   pKEYTYPE,
44   pKEYLENGTH,
45   pKEYUSAGE,
46   pSUBKEYTYPE,
47   pSUBKEYLENGTH,
48   pSUBKEYUSAGE,
49   pNAMEREAL,
50   pNAMEEMAIL,
51   pNAMECOMMENT,
52   pPREFERENCES,
53   pREVOKER,
54   pUSERID,
55   pEXPIREDATE,
56   pKEYEXPIRE, /* in n seconds */
57   pSUBKEYEXPIRE, /* in n seconds */
58   pPASSPHRASE,
59   pPASSPHRASE_DEK,
60   pPASSPHRASE_S2K
61 };
62
63 struct para_data_s {
64     struct para_data_s *next;
65     int lnr;
66     enum para_name key;
67     union {
68         DEK *dek;
69         STRING2KEY *s2k;
70         u32 expire;
71         unsigned int usage;
72         struct revocation_key revkey;
73         char value[1];
74     } u;
75 };
76
77 struct output_control_s {
78     int lnr;
79     int dryrun;
80     int use_files;
81     struct {
82         char  *fname;
83         char  *newfname;
84         IOBUF stream;
85         armor_filter_context_t afx;
86     } pub;
87     struct {
88         char  *fname;
89         char  *newfname;
90         IOBUF stream;
91         armor_filter_context_t afx;
92     } sec;
93 };
94
95
96 struct opaque_data_usage_and_pk {
97     unsigned int usage;
98     PKT_public_key *pk;
99 };
100
101
102 static int prefs_initialized = 0;
103 static byte sym_prefs[MAX_PREFS];
104 static int nsym_prefs;
105 static byte hash_prefs[MAX_PREFS];
106 static int nhash_prefs;
107 static byte zip_prefs[MAX_PREFS];
108 static int nzip_prefs;
109 static int mdc_available,ks_modify;
110
111 static void do_generate_keypair( struct para_data_s *para,
112                                  struct output_control_s *outctrl );
113 static int  write_keyblock( IOBUF out, KBNODE node );
114
115
116 static void
117 write_uid( KBNODE root, const char *s )
118 {
119     PACKET *pkt = m_alloc_clear(sizeof *pkt );
120     size_t n = strlen(s);
121
122     pkt->pkttype = PKT_USER_ID;
123     pkt->pkt.user_id = m_alloc_clear( sizeof *pkt->pkt.user_id + n - 1 );
124     pkt->pkt.user_id->len = n;
125     pkt->pkt.user_id->ref = 1;
126     strcpy(pkt->pkt.user_id->name, s);
127     add_kbnode( root, new_kbnode( pkt ) );
128 }
129
130 static void
131 do_add_key_flags (PKT_signature *sig, unsigned int use)
132 {
133     byte buf[1];
134
135     if (!use) 
136         return;
137
138     buf[0] = 0;
139     if (use & PUBKEY_USAGE_SIG)
140         buf[0] |= 0x01 | 0x02;
141     if (use & PUBKEY_USAGE_ENC)
142         buf[0] |= 0x04 | 0x08;
143     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, 1);
144 }
145
146
147 int
148 keygen_add_key_expire( PKT_signature *sig, void *opaque )
149 {
150     PKT_public_key *pk = opaque;
151     byte buf[8];
152     u32  u;
153
154     if( pk->expiredate ) {
155         if(pk->expiredate > pk->timestamp)
156           u= pk->expiredate - pk->timestamp;
157         else
158           u= 0;
159
160         buf[0] = (u >> 24) & 0xff;
161         buf[1] = (u >> 16) & 0xff;
162         buf[2] = (u >>  8) & 0xff;
163         buf[3] = u & 0xff;
164         build_sig_subpkt( sig, SIGSUBPKT_KEY_EXPIRE, buf, 4 );
165     }
166     else
167       {
168         /* Make sure we don't leave a key expiration subpacket lying
169            around */
170         delete_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE);
171       }
172
173     return 0;
174 }
175
176 static int
177 keygen_add_key_flags_and_expire (PKT_signature *sig, void *opaque)
178 {
179     struct opaque_data_usage_and_pk *oduap = opaque;
180
181     do_add_key_flags (sig, oduap->usage);
182     return keygen_add_key_expire (sig, oduap->pk);
183 }
184
185 static int
186 set_one_pref (int val, int type, const char *item, byte *buf, int *nbuf)
187 {
188     int i;
189
190     for (i=0; i < *nbuf; i++ )
191       if (buf[i] == val)
192         {
193           log_info (_("preference `%s' duplicated\n"), item);
194           return -1;
195         }
196
197     if (*nbuf >= MAX_PREFS)
198       {
199         if(type==1)
200           log_info(_("too many cipher preferences\n"));
201         else if(type==2)
202           log_info(_("too many digest preferences\n"));
203         else if(type==3)
204           log_info(_("too many compression preferences\n"));
205         else
206           BUG();
207
208         return -1;
209       }
210
211     buf[(*nbuf)++] = val;
212     return 0;
213 }
214
215 #ifdef USE_AES
216 #define AES "S7 "
217 #else
218 #define AES ""
219 #endif
220
221 #ifdef USE_CAST5
222 #define CAST5 "S3 "
223 #else
224 #define CAST5 ""
225 #endif
226
227 /*
228  * Parse the supplied string and use it to set the standard
229  * preferences.  The string may be in a form like the one printed by
230  * "pref" (something like: "S10 S3 H3 H2 Z2 Z1") or the actual
231  * cipher/hash/compress names.  Use NULL to set the default
232  * preferences.  Returns: 0 = okay
233  */
234 int
235 keygen_set_std_prefs (const char *string,int personal)
236 {
237     byte sym[MAX_PREFS], hash[MAX_PREFS], zip[MAX_PREFS];
238     int nsym=0, nhash=0, nzip=0, val, rc=0;
239     int mdc=1, modify=0; /* mdc defaults on, modify defaults off. */
240
241     if (!string || !ascii_strcasecmp (string, "default")) {
242       if (opt.def_preference_list)
243         string=opt.def_preference_list;
244       else if ( !check_cipher_algo(CIPHER_ALGO_IDEA) )
245         string = AES CAST5 "S2 S1 H2 H3 Z2 Z1";
246       else
247         string = AES CAST5 "S2 H2 H3 Z2 Z1";
248
249       /* If we have it, IDEA goes *after* 3DES so it won't be used
250          unless we're encrypting along with a V3 key.  Ideally, we
251          would only put the S1 preference in if the key was RSA and
252          <=2048 bits, as that is what won't break PGP2, but that is
253          difficult with the current code, and not really worth
254          checking as a non-RSA <=2048 bit key wouldn't be usable by
255          PGP2 anyway. -dms */
256     }
257     else if (!ascii_strcasecmp (string, "none"))
258         string = "";
259
260     if(strlen(string))
261       {
262         char *tok,*prefstring;
263
264         prefstring=m_strdup(string); /* need a writable string! */
265
266         while((tok=strsep(&prefstring," ,")))
267           {
268             if((val=string_to_cipher_algo(tok)))
269               {
270                 if(set_one_pref(val,1,tok,sym,&nsym))
271                   rc=-1;
272               }
273             else if((val=string_to_digest_algo(tok)))
274               {
275                 if(set_one_pref(val,2,tok,hash,&nhash))
276                   rc=-1;
277               }
278             else if((val=string_to_compress_algo(tok))>-1)
279               {
280                 if(set_one_pref(val,3,tok,zip,&nzip))
281                   rc=-1;
282               }
283             else if (ascii_strcasecmp(tok,"mdc")==0)
284               mdc=1;
285             else if (ascii_strcasecmp(tok,"no-mdc")==0)
286               mdc=0;
287             else if (ascii_strcasecmp(tok,"ks-modify")==0)
288               modify=1;
289             else if (ascii_strcasecmp(tok,"no-ks-modify")==0)
290               modify=0;
291             else
292               {
293                 log_info (_("invalid item `%s' in preference string\n"),tok);
294
295                 /* Complain if IDEA is not available. */
296                 if(ascii_strcasecmp(tok,"s1")==0
297                    || ascii_strcasecmp(tok,"idea")==0)
298                   idea_cipher_warn(1);
299
300                 rc=-1;
301               }
302           }
303
304         m_free(prefstring);
305       }
306
307     if(!rc)
308       {
309         if(personal)
310           {
311             if(personal==PREFTYPE_SYM)
312               {
313                 m_free(opt.personal_cipher_prefs);
314
315                 if(nsym==0)
316                   opt.personal_cipher_prefs=NULL;
317                 else
318                   {
319                     int i;
320
321                     opt.personal_cipher_prefs=
322                       m_alloc(sizeof(prefitem_t *)*(nsym+1));
323
324                     for (i=0; i<nsym; i++)
325                       {
326                         opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
327                         opt.personal_cipher_prefs[i].value = sym[i];
328                       }
329
330                     opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
331                     opt.personal_cipher_prefs[i].value = 0;
332                   }
333               }
334             else if(personal==PREFTYPE_HASH)
335               {
336                 m_free(opt.personal_digest_prefs);
337
338                 if(nhash==0)
339                   opt.personal_digest_prefs=NULL;
340                 else
341                   {
342                     int i;
343
344                     opt.personal_digest_prefs=
345                       m_alloc(sizeof(prefitem_t *)*(nhash+1));
346
347                     for (i=0; i<nhash; i++)
348                       {
349                         opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
350                         opt.personal_digest_prefs[i].value = hash[i];
351                       }
352
353                     opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
354                     opt.personal_digest_prefs[i].value = 0;
355                   }
356               }
357             else if(personal==PREFTYPE_ZIP)
358               {
359                 m_free(opt.personal_compress_prefs);
360
361                 if(nzip==0)
362                   opt.personal_compress_prefs=NULL;
363                 else
364                   {
365                     int i;
366
367                     opt.personal_compress_prefs=
368                       m_alloc(sizeof(prefitem_t *)*(nzip+1));
369
370                     for (i=0; i<nzip; i++)
371                       {
372                         opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
373                         opt.personal_compress_prefs[i].value = zip[i];
374                       }
375
376                     opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
377                     opt.personal_compress_prefs[i].value = 0;
378                   }
379               }
380           }
381         else
382           {
383             memcpy (sym_prefs,  sym,  (nsym_prefs=nsym));
384             memcpy (hash_prefs, hash, (nhash_prefs=nhash));
385             memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
386             mdc_available = mdc;
387             ks_modify = modify;
388             prefs_initialized = 1;
389           }
390       }
391
392     return rc;
393 }
394
395 #undef CAST5
396 #undef AES
397
398 /* Return a fake user ID containing the preferences.  Caller must
399    free. */
400 PKT_user_id *keygen_get_std_prefs(void)
401 {
402   int i,j=0;
403   PKT_user_id *uid=m_alloc_clear(sizeof(PKT_user_id));
404
405   if(!prefs_initialized)
406     keygen_set_std_prefs(NULL,0);
407
408   uid->prefs=m_alloc((sizeof(prefitem_t *)*
409                       (nsym_prefs+nhash_prefs+nzip_prefs+1)));
410
411   for(i=0;i<nsym_prefs;i++,j++)
412     {
413       uid->prefs[j].type=PREFTYPE_SYM;
414       uid->prefs[j].value=sym_prefs[i];
415     }
416
417   for(i=0;i<nhash_prefs;i++,j++)
418     {
419       uid->prefs[j].type=PREFTYPE_HASH;
420       uid->prefs[j].value=hash_prefs[i];
421     }
422
423   for(i=0;i<nzip_prefs;i++,j++)
424     {
425       uid->prefs[j].type=PREFTYPE_ZIP;
426       uid->prefs[j].value=zip_prefs[i];
427     }
428
429   uid->prefs[j].type=PREFTYPE_NONE;
430   uid->prefs[j].value=0;
431
432   uid->mdc_feature=mdc_available;
433   uid->ks_modify=ks_modify;
434
435   return uid;
436 }
437
438 static void
439 add_feature_mdc (PKT_signature *sig,int enabled)
440 {
441     const byte *s;
442     size_t n;
443     int i;
444     char *buf;
445
446     s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n );
447     /* Already set or cleared */
448     if (s && n &&
449         ((enabled && (s[0] & 0x01)) || (!enabled && !(s[0] & 0x01))))
450       return;
451
452     if (!s || !n) { /* create a new one */
453         n = 1;
454         buf = m_alloc_clear (n);
455     }
456     else {
457         buf = m_alloc (n);
458         memcpy (buf, s, n);
459     }
460
461     if(enabled)
462       buf[0] |= 0x01; /* MDC feature */
463     else
464       buf[0] &= ~0x01;
465
466     /* Are there any bits set? */
467     for(i=0;i<n;i++)
468       if(buf[i]!=0)
469         break;
470
471     if(i==n)
472       delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
473     else
474       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
475
476     m_free (buf);
477 }
478
479 static void
480 add_keyserver_modify (PKT_signature *sig,int enabled)
481 {
482   const byte *s;
483   size_t n;
484   int i;
485   char *buf;
486
487   /* The keyserver modify flag is a negative flag (i.e. no-modify) */
488   enabled=!enabled;
489
490   s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n );
491   /* Already set or cleared */
492   if (s && n &&
493       ((enabled && (s[0] & 0x80)) || (!enabled && !(s[0] & 0x80))))
494     return;
495
496   if (!s || !n) { /* create a new one */
497     n = 1;
498     buf = m_alloc_clear (n);
499   }
500   else {
501     buf = m_alloc (n);
502     memcpy (buf, s, n);
503   }
504
505   if(enabled)
506     buf[0] |= 0x80; /* no-modify flag */
507   else
508     buf[0] &= ~0x80;
509
510   /* Are there any bits set? */
511   for(i=0;i<n;i++)
512     if(buf[i]!=0)
513       break;
514
515   if(i==n)
516     delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
517   else
518     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
519
520   m_free (buf);
521 }
522
523 int
524 keygen_upd_std_prefs( PKT_signature *sig, void *opaque )
525 {
526     if (!prefs_initialized)
527         keygen_set_std_prefs (NULL, 0);
528
529     if (nsym_prefs) 
530         build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
531     else
532       {
533         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
534         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
535       }
536
537     if (nhash_prefs)
538         build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
539     else
540       {
541         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
542         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
543       }
544
545     if (nzip_prefs)
546         build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
547     else
548       {
549         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
550         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
551       }
552
553     /* Make sure that the MDC feature flag is set if needed */
554     add_feature_mdc (sig,mdc_available);
555     add_keyserver_modify (sig,ks_modify);
556
557     return 0;
558 }
559
560
561 /****************
562  * Add preference to the self signature packet.
563  * This is only called for packets with version > 3.
564
565  */
566 int
567 keygen_add_std_prefs( PKT_signature *sig, void *opaque )
568 {
569     PKT_public_key *pk = opaque;
570
571     do_add_key_flags (sig, pk->pubkey_usage);
572     keygen_add_key_expire( sig, opaque );
573     keygen_upd_std_prefs (sig, opaque);
574
575     return 0;
576 }
577
578 int
579 keygen_add_revkey(PKT_signature *sig, void *opaque)
580 {
581   struct revocation_key *revkey=opaque;
582   byte buf[2+MAX_FINGERPRINT_LEN];
583
584   buf[0]=revkey->class;
585   buf[1]=revkey->algid;
586   memcpy(&buf[2],revkey->fpr,MAX_FINGERPRINT_LEN);
587
588   build_sig_subpkt(sig,SIGSUBPKT_REV_KEY,buf,2+MAX_FINGERPRINT_LEN);
589
590   /* All sigs with revocation keys set are nonrevocable */
591   sig->flags.revocable=0;
592   buf[0] = 0;
593   build_sig_subpkt( sig, SIGSUBPKT_REVOCABLE, buf, 1 );
594
595   parse_revkeys(sig);
596
597   return 0;
598 }
599
600 static int
601 write_direct_sig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
602                   struct revocation_key *revkey )
603 {
604     PACKET *pkt;
605     PKT_signature *sig;
606     int rc=0;
607     KBNODE node;
608     PKT_public_key *pk;
609
610     if( opt.verbose )
611         log_info(_("writing direct signature\n"));
612
613     /* get the pk packet from the pub_tree */
614     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
615     if( !node )
616         BUG();
617     pk = node->pkt->pkt.public_key;
618
619     /* we have to cache the key, so that the verification of the signature
620      * creation is able to retrieve the public key */
621     cache_public_key (pk);
622
623     /* and make the signature */
624     rc = make_keysig_packet(&sig,pk,NULL,NULL,sk,0x1F,0,0,0,0,
625                             keygen_add_revkey,revkey);
626     if( rc ) {
627         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
628         return rc;
629     }
630
631     pkt = m_alloc_clear( sizeof *pkt );
632     pkt->pkttype = PKT_SIGNATURE;
633     pkt->pkt.signature = sig;
634     add_kbnode( root, new_kbnode( pkt ) );
635     return rc;
636 }
637
638 static int
639 write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
640                unsigned int use )
641 {
642     PACKET *pkt;
643     PKT_signature *sig;
644     PKT_user_id *uid;
645     int rc=0;
646     KBNODE node;
647     PKT_public_key *pk;
648
649     if( opt.verbose )
650         log_info(_("writing self signature\n"));
651
652     /* get the uid packet from the list */
653     node = find_kbnode( root, PKT_USER_ID );
654     if( !node )
655         BUG(); /* no user id packet in tree */
656     uid = node->pkt->pkt.user_id;
657     /* get the pk packet from the pub_tree */
658     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
659     if( !node )
660         BUG();
661     pk = node->pkt->pkt.public_key;
662     pk->pubkey_usage = use;
663     /* we have to cache the key, so that the verification of the signature
664      * creation is able to retrieve the public key */
665     cache_public_key (pk);
666
667     /* and make the signature */
668     rc = make_keysig_packet( &sig, pk, uid, NULL, sk, 0x13, 0, 0, 0, 0,
669                              keygen_add_std_prefs, pk );
670     if( rc ) {
671         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
672         return rc;
673     }
674
675     pkt = m_alloc_clear( sizeof *pkt );
676     pkt->pkttype = PKT_SIGNATURE;
677     pkt->pkt.signature = sig;
678     add_kbnode( root, new_kbnode( pkt ) );
679     return rc;
680 }
681
682 static int
683 write_keybinding( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
684                   unsigned int use )
685 {
686     PACKET *pkt;
687     PKT_signature *sig;
688     int rc=0;
689     KBNODE node;
690     PKT_public_key *pk, *subpk;
691     struct opaque_data_usage_and_pk oduap;
692
693     if( opt.verbose )
694         log_info(_("writing key binding signature\n"));
695
696     /* get the pk packet from the pub_tree */
697     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
698     if( !node )
699         BUG();
700     pk = node->pkt->pkt.public_key;
701     /* we have to cache the key, so that the verification of the signature
702      * creation is able to retrieve the public key */
703     cache_public_key (pk);
704  
705     /* find the last subkey */
706     subpk = NULL;
707     for(node=pub_root; node; node = node->next ) {
708         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
709             subpk = node->pkt->pkt.public_key;
710     }
711     if( !subpk )
712         BUG();
713
714     /* and make the signature */
715     oduap.usage = use;
716     oduap.pk = subpk;
717     rc = make_keysig_packet( &sig, pk, NULL, subpk, sk, 0x18, 0, 0, 0, 0,
718                              keygen_add_key_flags_and_expire, &oduap );
719     if( rc ) {
720         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
721         return rc;
722     }
723
724     pkt = m_alloc_clear( sizeof *pkt );
725     pkt->pkttype = PKT_SIGNATURE;
726     pkt->pkt.signature = sig;
727     add_kbnode( root, new_kbnode( pkt ) );
728     return rc;
729 }
730
731
732 static int
733 gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
734         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
735 {
736     int rc;
737     int i;
738     PACKET *pkt;
739     PKT_secret_key *sk;
740     PKT_public_key *pk;
741     MPI skey[4];
742     MPI *factors;
743
744     assert( is_ELGAMAL(algo) );
745
746     if( nbits < 512 ) {
747         nbits = 1024;
748         log_info(_("keysize invalid; using %u bits\n"), nbits );
749     }
750
751     if( (nbits % 32) ) {
752         nbits = ((nbits + 31) / 32) * 32;
753         log_info(_("keysize rounded up to %u bits\n"), nbits );
754     }
755
756     rc = pubkey_generate( algo, nbits, skey, &factors );
757     if( rc ) {
758         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
759         return rc;
760     }
761
762     sk = m_alloc_clear( sizeof *sk );
763     pk = m_alloc_clear( sizeof *pk );
764     sk->timestamp = pk->timestamp = make_timestamp();
765     sk->version = pk->version = 4;
766     if( expireval ) {
767         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
768     }
769     sk->pubkey_algo = pk->pubkey_algo = algo;
770                        pk->pkey[0] = mpi_copy( skey[0] );
771                        pk->pkey[1] = mpi_copy( skey[1] );
772                        pk->pkey[2] = mpi_copy( skey[2] );
773     sk->skey[0] = skey[0];
774     sk->skey[1] = skey[1];
775     sk->skey[2] = skey[2];
776     sk->skey[3] = skey[3];
777     sk->is_protected = 0;
778     sk->protect.algo = 0;
779
780     sk->csum = checksum_mpi( sk->skey[3] );
781     if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
782         *ret_sk = copy_secret_key( NULL, sk );
783
784     if( dek ) {
785         sk->protect.algo = dek->algo;
786         sk->protect.s2k = *s2k;
787         rc = protect_secret_key( sk, dek );
788         if( rc ) {
789             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
790             free_public_key(pk);
791             free_secret_key(sk);
792             return rc;
793         }
794     }
795
796     pkt = m_alloc_clear(sizeof *pkt);
797     pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
798     pkt->pkt.public_key = pk;
799     add_kbnode(pub_root, new_kbnode( pkt ));
800
801     /* don't know whether it makes sense to have the factors, so for now
802      * we store them in the secret keyring (but they are not secret) */
803     pkt = m_alloc_clear(sizeof *pkt);
804     pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
805     pkt->pkt.secret_key = sk;
806     add_kbnode(sec_root, new_kbnode( pkt ));
807     for(i=0; factors[i]; i++ )
808         add_kbnode( sec_root,
809                     make_mpi_comment_node("#:ELG_factor:", factors[i] ));
810
811     return 0;
812 }
813
814
815 /****************
816  * Generate a DSA key
817  */
818 static int
819 gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
820             STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
821 {
822     int rc;
823     int i;
824     PACKET *pkt;
825     PKT_secret_key *sk;
826     PKT_public_key *pk;
827     MPI skey[5];
828     MPI *factors;
829
830     if( nbits > 1024 || nbits < 512 ) {
831         nbits = 1024;
832         log_info(_("keysize invalid; using %u bits\n"), nbits );
833     }
834
835     if( (nbits % 64) ) {
836         nbits = ((nbits + 63) / 64) * 64;
837         log_info(_("keysize rounded up to %u bits\n"), nbits );
838     }
839
840     rc = pubkey_generate( PUBKEY_ALGO_DSA, nbits, skey, &factors );
841     if( rc ) {
842         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
843         return rc;
844     }
845
846     sk = m_alloc_clear( sizeof *sk );
847     pk = m_alloc_clear( sizeof *pk );
848     sk->timestamp = pk->timestamp = make_timestamp();
849     sk->version = pk->version = 4;
850     if( expireval ) {
851         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
852     }
853     sk->pubkey_algo = pk->pubkey_algo = PUBKEY_ALGO_DSA;
854                        pk->pkey[0] = mpi_copy( skey[0] );
855                        pk->pkey[1] = mpi_copy( skey[1] );
856                        pk->pkey[2] = mpi_copy( skey[2] );
857                        pk->pkey[3] = mpi_copy( skey[3] );
858     sk->skey[0] = skey[0];
859     sk->skey[1] = skey[1];
860     sk->skey[2] = skey[2];
861     sk->skey[3] = skey[3];
862     sk->skey[4] = skey[4];
863     sk->is_protected = 0;
864     sk->protect.algo = 0;
865
866     sk->csum = checksum_mpi ( sk->skey[4] );
867     if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
868         *ret_sk = copy_secret_key( NULL, sk );
869
870     if( dek ) {
871         sk->protect.algo = dek->algo;
872         sk->protect.s2k = *s2k;
873         rc = protect_secret_key( sk, dek );
874         if( rc ) {
875             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
876             free_public_key(pk);
877             free_secret_key(sk);
878             return rc;
879         }
880     }
881
882     pkt = m_alloc_clear(sizeof *pkt);
883     pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
884     pkt->pkt.public_key = pk;
885     add_kbnode(pub_root, new_kbnode( pkt ));
886
887     /* don't know whether it makes sense to have the factors, so for now
888      * we store them in the secret keyring (but they are not secret)
889      * p = 2 * q * f1 * f2 * ... * fn
890      * We store only f1 to f_n-1;  fn can be calculated because p and q
891      * are known.
892      */
893     pkt = m_alloc_clear(sizeof *pkt);
894     pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
895     pkt->pkt.secret_key = sk;
896     add_kbnode(sec_root, new_kbnode( pkt ));
897     for(i=1; factors[i]; i++ )  /* the first one is q */
898         add_kbnode( sec_root,
899                     make_mpi_comment_node("#:DSA_factor:", factors[i] ));
900
901     return 0;
902 }
903
904
905 /* 
906  * Generate an RSA key.
907  */
908 static int
909 gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
910         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
911 {
912     int rc;
913     PACKET *pkt;
914     PKT_secret_key *sk;
915     PKT_public_key *pk;
916     MPI skey[6];
917     MPI *factors;
918
919     assert( is_RSA(algo) );
920
921     if( nbits < 1024 ) {
922         nbits = 1024;
923         log_info(_("keysize invalid; using %u bits\n"), nbits );
924     }
925
926     if( (nbits % 32) ) {
927         nbits = ((nbits + 31) / 32) * 32;
928         log_info(_("keysize rounded up to %u bits\n"), nbits );
929     }
930
931     rc = pubkey_generate( algo, nbits, skey, &factors );
932     if( rc ) {
933         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
934         return rc;
935     }
936
937     sk = m_alloc_clear( sizeof *sk );
938     pk = m_alloc_clear( sizeof *pk );
939     sk->timestamp = pk->timestamp = make_timestamp();
940     sk->version = pk->version = 4;
941     if( expireval ) {
942         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
943     }
944     sk->pubkey_algo = pk->pubkey_algo = algo;
945                        pk->pkey[0] = mpi_copy( skey[0] );
946                        pk->pkey[1] = mpi_copy( skey[1] );
947     sk->skey[0] = skey[0];
948     sk->skey[1] = skey[1];
949     sk->skey[2] = skey[2];
950     sk->skey[3] = skey[3];
951     sk->skey[4] = skey[4];
952     sk->skey[5] = skey[5];
953     sk->is_protected = 0;
954     sk->protect.algo = 0;
955
956     sk->csum  = checksum_mpi (sk->skey[2] );
957     sk->csum += checksum_mpi (sk->skey[3] );
958     sk->csum += checksum_mpi (sk->skey[4] );
959     sk->csum += checksum_mpi (sk->skey[5] );
960     if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
961         *ret_sk = copy_secret_key( NULL, sk );
962
963     if( dek ) {
964         sk->protect.algo = dek->algo;
965         sk->protect.s2k = *s2k;
966         rc = protect_secret_key( sk, dek );
967         if( rc ) {
968             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
969             free_public_key(pk);
970             free_secret_key(sk);
971             return rc;
972         }
973     }
974
975     pkt = m_alloc_clear(sizeof *pkt);
976     pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
977     pkt->pkt.public_key = pk;
978     add_kbnode(pub_root, new_kbnode( pkt ));
979
980     pkt = m_alloc_clear(sizeof *pkt);
981     pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
982     pkt->pkt.secret_key = sk;
983     add_kbnode(sec_root, new_kbnode( pkt ));
984
985     return 0;
986 }
987
988
989 /****************
990  * check valid days:
991  * return 0 on error or the multiplier
992  */
993 static int
994 check_valid_days( const char *s )
995 {
996     if( !isdigit(*s) )
997         return 0;
998     for( s++; *s; s++)
999         if( !isdigit(*s) )
1000             break;
1001     if( !*s )
1002         return 1;
1003     if( s[1] )
1004         return 0; /* e.g. "2323wc" */
1005     if( *s == 'd' || *s == 'D' )
1006         return 1;
1007     if( *s == 'w' || *s == 'W' )
1008         return 7;
1009     if( *s == 'm' || *s == 'M' )
1010         return 30;
1011     if( *s == 'y' || *s == 'Y' )
1012         return 365;
1013     return 0;
1014 }
1015
1016
1017 /****************
1018  * Returns: 0 to create both a DSA and a ElGamal key.
1019  *          and only if key flags are to be written the desired usage.
1020  */
1021 static int
1022 ask_algo (int addmode, unsigned int *r_usage)
1023 {
1024     char *answer;
1025     int algo;
1026
1027     *r_usage = 0;
1028     tty_printf(_("Please select what kind of key you want:\n"));
1029     if( !addmode )
1030         tty_printf(_("   (%d) DSA and ElGamal (default)\n"), 1 );
1031     tty_printf(    _("   (%d) DSA (sign only)\n"), 2 );
1032     if( addmode )
1033         tty_printf(    _("   (%d) ElGamal (encrypt only)\n"), 3 );
1034     if (opt.expert)
1035         tty_printf(    _("   (%d) ElGamal (sign and encrypt)\n"), 4 );
1036     tty_printf(    _("   (%d) RSA (sign only)\n"), 5 );
1037     if (addmode)
1038         tty_printf(    _("   (%d) RSA (encrypt only)\n"), 6 );
1039     if (opt.expert)
1040       tty_printf(    _("   (%d) RSA (sign and encrypt)\n"), 7 );
1041
1042     for(;;) {
1043         answer = cpr_get("keygen.algo",_("Your selection? "));
1044         cpr_kill_prompt();
1045         algo = *answer? atoi(answer): 1;
1046         m_free(answer);
1047         if( algo == 1 && !addmode ) {
1048             algo = 0;   /* create both keys */
1049             break;
1050         }
1051         else if( algo == 7 && opt.expert ) {
1052             algo = PUBKEY_ALGO_RSA;
1053             *r_usage = PUBKEY_USAGE_ENC | PUBKEY_USAGE_SIG;
1054             break;
1055         }
1056         else if( algo == 6 && addmode ) {
1057             algo = PUBKEY_ALGO_RSA;
1058             *r_usage = PUBKEY_USAGE_ENC;
1059             break;
1060         }
1061         else if( algo == 5 ) {
1062             algo = PUBKEY_ALGO_RSA;
1063             *r_usage = PUBKEY_USAGE_SIG;
1064             break;
1065         }
1066         else if( algo == 4 && opt.expert)
1067           {
1068             tty_printf(_(
1069 "The use of this algorithm is only supported by GnuPG.  You will not be\n"
1070 "able to use this key to communicate with PGP users.  This algorithm is also\n"
1071 "very slow, and may not be as secure as the other choices.\n"));
1072
1073             if( cpr_get_answer_is_yes("keygen.algo.elg_se",
1074                                       _("Create anyway? ")))
1075               {
1076                 algo = PUBKEY_ALGO_ELGAMAL;
1077                 break;
1078               }
1079         }
1080         else if( algo == 3 && addmode ) {
1081             algo = PUBKEY_ALGO_ELGAMAL_E;
1082             break;
1083         }
1084         else if( algo == 2 ) {
1085             algo = PUBKEY_ALGO_DSA;
1086             break;
1087         }
1088         else
1089             tty_printf(_("Invalid selection.\n"));
1090     }
1091     return algo;
1092 }
1093
1094
1095 static unsigned
1096 ask_keysize( int algo )
1097 {
1098     char *answer;
1099     unsigned nbits;
1100
1101     if (algo != PUBKEY_ALGO_DSA && algo != PUBKEY_ALGO_RSA) {
1102         tty_printf (_("About to generate a new %s keypair.\n"
1103                       "              minimum keysize is  768 bits\n"
1104                       "              default keysize is 1024 bits\n"
1105                       "    highest suggested keysize is 2048 bits\n"),
1106                     pubkey_algo_to_string(algo) );
1107     }
1108
1109     for(;;) {
1110         answer = cpr_get("keygen.size",
1111                           _("What keysize do you want? (1024) "));
1112         cpr_kill_prompt();
1113         nbits = *answer? atoi(answer): 1024;
1114         m_free(answer);
1115         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
1116             tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
1117         else if( algo == PUBKEY_ALGO_RSA && nbits < 1024 )
1118             tty_printf(_("keysize too small;"
1119                          " 1024 is smallest value allowed for RSA.\n"));
1120         else if( nbits < 768 )
1121             tty_printf(_("keysize too small;"
1122                          " 768 is smallest value allowed.\n"));
1123         else if( nbits > 4096 ) {
1124             /* It is ridiculous and an annoyance to use larger key sizes!
1125              * GnuPG can handle much larger sizes; but it takes an eternity
1126              * to create such a key (but less than the time the Sirius
1127              * Computer Corporation needs to process one of the usual
1128              * complaints) and {de,en}cryption although needs some time.
1129              * So, before you complain about this limitation, I suggest that
1130              * you start a discussion with Marvin about this theme and then
1131              * do whatever you want. */
1132             tty_printf(_("keysize too large; %d is largest value allowed.\n"),
1133                                                                          4096);
1134         }
1135         else if( nbits > 2048 && !cpr_enabled() ) {
1136             tty_printf(
1137                 _("Keysizes larger than 2048 are not suggested because\n"
1138                   "computations take REALLY long!\n"));
1139             if( cpr_get_answer_is_yes("keygen.size.huge.okay",_(
1140                         "Are you sure that you want this keysize? ")) ) {
1141                 tty_printf(_("Okay, but keep in mind that your monitor "
1142                              "and keyboard radiation is also very vulnerable "
1143                              "to attacks!\n"));
1144                 break;
1145             }
1146         }
1147         else
1148             break;
1149     }
1150     tty_printf(_("Requested keysize is %u bits\n"), nbits );
1151     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
1152         nbits = ((nbits + 63) / 64) * 64;
1153         tty_printf(_("rounded up to %u bits\n"), nbits );
1154     }
1155     else if( (nbits % 32) ) {
1156         nbits = ((nbits + 31) / 32) * 32;
1157         tty_printf(_("rounded up to %u bits\n"), nbits );
1158     }
1159     return nbits;
1160 }
1161
1162
1163 /****************
1164  * Parse an expire string and return it's value in days.
1165  * Returns -1 on error.
1166  */
1167 static int
1168 parse_expire_string( const char *string )
1169 {
1170     int mult;
1171     u32 abs_date=0;
1172     u32 curtime = make_timestamp();
1173     int valid_days;
1174
1175     if( !*string )
1176         valid_days = 0;
1177     else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime ) {
1178         /* This calculation is not perfectly okay because we
1179          * are later going to simply multiply by 86400 and don't
1180          * correct for leapseconds.  A solution would be to change
1181          * the whole implemenation to work with dates and not intervals
1182          * which are required for v3 keys.
1183          */
1184         valid_days = abs_date/86400-curtime/86400+1;
1185     }
1186     else if( (mult=check_valid_days(string)) ) {
1187         valid_days = atoi(string) * mult;
1188         if( valid_days < 0 || valid_days > 39447 )
1189             valid_days = 0;
1190     }
1191     else {
1192         valid_days = -1;
1193     }
1194     return valid_days;
1195 }
1196
1197 /* object == 0 for a key, and 1 for a sig */
1198 u32
1199 ask_expire_interval(int object)
1200 {
1201     char *answer;
1202     int valid_days=0;
1203     u32 interval = 0;
1204
1205     switch(object)
1206       {
1207       case 0:
1208         tty_printf(_("Please specify how long the key should be valid.\n"
1209                      "         0 = key does not expire\n"
1210                      "      <n>  = key expires in n days\n"
1211                      "      <n>w = key expires in n weeks\n"
1212                      "      <n>m = key expires in n months\n"
1213                      "      <n>y = key expires in n years\n"));
1214         break;
1215
1216       case 1:
1217         tty_printf(_("Please specify how long the signature should be valid.\n"
1218                      "         0 = signature does not expire\n"
1219                      "      <n>  = signature expires in n days\n"
1220                      "      <n>w = signature expires in n weeks\n"
1221                      "      <n>m = signature expires in n months\n"
1222                      "      <n>y = signature expires in n years\n"));
1223         break;
1224
1225       default:
1226         BUG();
1227       }
1228
1229     /* Note: The elgamal subkey for DSA has no expiration date because
1230      * it must be signed with the DSA key and this one has the expiration
1231      * date */
1232
1233     answer = NULL;
1234     for(;;) {
1235         u32 curtime=make_timestamp();
1236
1237         m_free(answer);
1238         if(object==0)
1239           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1240         else
1241           answer = cpr_get("siggen.valid",_("Signature is valid for? (0) "));
1242         cpr_kill_prompt();
1243         trim_spaces(answer);
1244         valid_days = parse_expire_string( answer );
1245         if( valid_days < 0 ) {
1246             tty_printf(_("invalid value\n"));
1247             continue;
1248         }
1249
1250         if( !valid_days ) {
1251             tty_printf(_("%s does not expire at all\n"),
1252                        object==0?"Key":"Signature");
1253             interval = 0;
1254         }
1255         else {
1256             interval = valid_days * 86400L;
1257             /* print the date when the key expires */
1258             tty_printf(_("%s expires at %s\n"),
1259                         object==0?"Key":"Signature",
1260                         asctimestamp((ulong)(curtime + interval) ) );
1261             /* FIXME: This check yields warning on alhas:
1262                write a configure check and to this check here only for 32 bit machines */
1263             if( (time_t)((ulong)(curtime+interval)) < 0 )
1264                 tty_printf(_("Your system can't display dates beyond 2038.\n"
1265                     "However, it will be correctly handled up to 2106.\n"));
1266         }
1267
1268         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1269                                             _("Is this correct (y/n)? ")) )
1270             break;
1271     }
1272     m_free(answer);
1273     return interval;
1274 }
1275
1276 u32
1277 ask_expiredate()
1278 {
1279     u32 x = ask_expire_interval(0);
1280     return x? make_timestamp() + x : 0;
1281 }
1282
1283 static int
1284 has_invalid_email_chars( const char *s )
1285 {
1286     int at_seen=0;
1287     static char valid_chars[] = "01234567890_-."
1288                                 "abcdefghijklmnopqrstuvwxyz"
1289                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1290
1291     for( ; *s; s++ ) {
1292         if( *s & 0x80 )
1293             return 1;
1294         if( *s == '@' )
1295             at_seen=1;
1296         else if( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1297             return 1;
1298         else if( at_seen && !strchr( valid_chars, *s ) )
1299             return 1;
1300     }
1301     return 0;
1302 }
1303
1304
1305 static char *
1306 ask_user_id( int mode )
1307 {
1308     char *answer;
1309     char *aname, *acomment, *amail, *uid;
1310
1311     if( !mode )
1312         tty_printf( _("\n"
1313 "You need a User-ID to identify your key; the software constructs the user id\n"
1314 "from Real Name, Comment and Email Address in this form:\n"
1315 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
1316     uid = aname = acomment = amail = NULL;
1317     for(;;) {
1318         char *p;
1319         int fail=0;
1320
1321         if( !aname ) {
1322             for(;;) {
1323                 m_free(aname);
1324                 aname = cpr_get("keygen.name",_("Real name: "));
1325                 trim_spaces(aname);
1326                 cpr_kill_prompt();
1327
1328                 if( opt.allow_freeform_uid )
1329                     break;
1330
1331                 if( strpbrk( aname, "<>" ) )
1332                     tty_printf(_("Invalid character in name\n"));
1333                 else if( isdigit(*aname) )
1334                     tty_printf(_("Name may not start with a digit\n"));
1335                 else if( strlen(aname) < 5 )
1336                     tty_printf(_("Name must be at least 5 characters long\n"));
1337                 else
1338                     break;
1339             }
1340         }
1341         if( !amail ) {
1342             for(;;) {
1343                 m_free(amail);
1344                 amail = cpr_get("keygen.email",_("Email address: "));
1345                 trim_spaces(amail);
1346                 cpr_kill_prompt();
1347                 if( !*amail )
1348                     break;   /* no email address is okay */
1349                 else if( has_invalid_email_chars(amail)
1350                          || string_count_chr(amail,'@') != 1
1351                          || *amail == '@'
1352                          || amail[strlen(amail)-1] == '@'
1353                          || amail[strlen(amail)-1] == '.'
1354                          || strstr(amail, "..") )
1355                     tty_printf(_("Not a valid email address\n"));
1356                 else
1357                     break;
1358             }
1359         }
1360         if( !acomment ) {
1361             for(;;) {
1362                 m_free(acomment);
1363                 acomment = cpr_get("keygen.comment",_("Comment: "));
1364                 trim_spaces(acomment);
1365                 cpr_kill_prompt();
1366                 if( !*acomment )
1367                     break;   /* no comment is okay */
1368                 else if( strpbrk( acomment, "()" ) )
1369                     tty_printf(_("Invalid character in comment\n"));
1370                 else
1371                     break;
1372             }
1373         }
1374
1375
1376         m_free(uid);
1377         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1378         p = stpcpy(p, aname );
1379         if( *acomment )
1380             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1381         if( *amail )
1382             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1383
1384         /* append a warning if we do not have dev/random
1385          * or it is switched into  quick testmode */
1386         if( quick_random_gen(-1) )
1387             strcpy(p, " (INSECURE!)" );
1388
1389         /* print a note in case that UTF8 mapping has to be done */
1390         for(p=uid; *p; p++ ) {
1391             if( *p & 0x80 ) {
1392                 tty_printf(_("You are using the `%s' character set.\n"),
1393                            get_native_charset() );
1394                 break;
1395             }
1396         }
1397
1398         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1399         /* fixme: add a warning if this user-id already exists */
1400         if( !*amail && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1401             fail = 1;
1402             tty_printf(_("Please don't put the email address "
1403                           "into the real name or the comment\n") );
1404         }
1405
1406         for(;;) {
1407             const char *ansstr = _("NnCcEeOoQq");
1408
1409             if( strlen(ansstr) != 10 )
1410                 BUG();
1411             if( cpr_enabled() ) {
1412                 answer = m_strdup(ansstr+6);
1413                 answer[1] = 0;
1414             }
1415             else {
1416                 answer = cpr_get("keygen.userid.cmd", fail?
1417                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1418                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1419                 cpr_kill_prompt();
1420             }
1421             if( strlen(answer) > 1 )
1422                 ;
1423             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1424                 m_free(aname); aname = NULL;
1425                 break;
1426             }
1427             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1428                 m_free(acomment); acomment = NULL;
1429                 break;
1430             }
1431             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1432                 m_free(amail); amail = NULL;
1433                 break;
1434             }
1435             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1436                 if( fail ) {
1437                     tty_printf(_("Please correct the error first\n"));
1438                 }
1439                 else {
1440                     m_free(aname); aname = NULL;
1441                     m_free(acomment); acomment = NULL;
1442                     m_free(amail); amail = NULL;
1443                     break;
1444                 }
1445             }
1446             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1447                 m_free(aname); aname = NULL;
1448                 m_free(acomment); acomment = NULL;
1449                 m_free(amail); amail = NULL;
1450                 m_free(uid); uid = NULL;
1451                 break;
1452             }
1453             m_free(answer);
1454         }
1455         m_free(answer);
1456         if( !amail && !acomment && !amail )
1457             break;
1458         m_free(uid); uid = NULL;
1459     }
1460     if( uid ) {
1461         char *p = native_to_utf8( uid );
1462         m_free( uid );
1463         uid = p;
1464     }
1465     return uid;
1466 }
1467
1468
1469 static DEK *
1470 ask_passphrase( STRING2KEY **ret_s2k )
1471 {
1472     DEK *dek = NULL;
1473     STRING2KEY *s2k;
1474     const char *errtext = NULL;
1475
1476     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1477
1478     s2k = m_alloc_secure( sizeof *s2k );
1479     for(;;) {
1480         s2k->mode = opt.s2k_mode;
1481         s2k->hash_algo = opt.s2k_digest_algo;
1482         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,errtext);
1483         if( !dek ) {
1484             errtext = _("passphrase not correctly repeated; try again");
1485             tty_printf(_("%s.\n"), errtext);
1486         }
1487         else if( !dek->keylen ) {
1488             m_free(dek); dek = NULL;
1489             m_free(s2k); s2k = NULL;
1490             tty_printf(_(
1491             "You don't want a passphrase - this is probably a *bad* idea!\n"
1492             "I will do it anyway.  You can change your passphrase at any time,\n"
1493             "using this program with the option \"--edit-key\".\n\n"));
1494             break;
1495         }
1496         else
1497             break; /* okay */
1498     }
1499     *ret_s2k = s2k;
1500     return dek;
1501 }
1502
1503
1504 static int
1505 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
1506            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate )
1507 {
1508     int rc=0;
1509
1510     if( !opt.batch )
1511         tty_printf(_(
1512 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1513 "some other action (type on the keyboard, move the mouse, utilize the\n"
1514 "disks) during the prime generation; this gives the random number\n"
1515 "generator a better chance to gain enough entropy.\n") );
1516
1517     if( algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E )
1518         rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1519     else if( algo == PUBKEY_ALGO_DSA )
1520         rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1521     else if( algo == PUBKEY_ALGO_RSA )
1522         rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1523     else
1524         BUG();
1525
1526   #ifdef ENABLE_COMMENT_PACKETS
1527     if( !rc ) {
1528         add_kbnode( pub_root,
1529                 make_comment_node("#created by GNUPG v" VERSION " ("
1530                                             PRINTABLE_OS_NAME ")"));
1531         add_kbnode( sec_root,
1532                 make_comment_node("#created by GNUPG v" VERSION " ("
1533                                             PRINTABLE_OS_NAME ")"));
1534     }
1535   #endif
1536     return rc;
1537 }
1538
1539
1540 /****************
1541  * Generate a new user id packet, or return NULL if canceled
1542  */
1543 PKT_user_id *
1544 generate_user_id()
1545 {
1546     PKT_user_id *uid;
1547     char *p;
1548     size_t n;
1549
1550     p = ask_user_id( 1 );
1551     if( !p )
1552         return NULL;
1553     n = strlen(p);
1554     uid = m_alloc_clear( sizeof *uid + n - 1 );
1555     uid->len = n;
1556     strcpy(uid->name, p);
1557     uid->ref = 1;
1558     return uid;
1559 }
1560
1561
1562 static void
1563 release_parameter_list( struct para_data_s *r )
1564 {
1565     struct para_data_s *r2;
1566
1567     for( ; r ; r = r2 ) {
1568         r2 = r->next;
1569         if( r->key == pPASSPHRASE_DEK )
1570             m_free( r->u.dek );
1571         else if( r->key == pPASSPHRASE_S2K )
1572             m_free( r->u.s2k );
1573
1574         m_free(r);
1575     }
1576 }
1577
1578 static struct para_data_s *
1579 get_parameter( struct para_data_s *para, enum para_name key )
1580 {
1581     struct para_data_s *r;
1582
1583     for( r = para; r && r->key != key; r = r->next )
1584         ;
1585     return r;
1586 }
1587
1588 static const char *
1589 get_parameter_value( struct para_data_s *para, enum para_name key )
1590 {
1591     struct para_data_s *r = get_parameter( para, key );
1592     return (r && *r->u.value)? r->u.value : NULL;
1593 }
1594
1595 static int
1596 get_parameter_algo( struct para_data_s *para, enum para_name key )
1597 {
1598     int i;
1599     struct para_data_s *r = get_parameter( para, key );
1600     if( !r )
1601         return -1;
1602     if( isdigit( *r->u.value ) )
1603         i = atoi( r->u.value );
1604     else
1605         i = string_to_pubkey_algo( r->u.value );
1606     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
1607       i = 0; /* we don't want to allow generation of these algorithms */
1608     return i;
1609 }
1610
1611 /* 
1612  * parse the usage parameter and set the keyflags.  Return true on error.
1613  */
1614 static int
1615 parse_parameter_usage (const char *fname,
1616                        struct para_data_s *para, enum para_name key)
1617 {
1618     struct para_data_s *r = get_parameter( para, key );
1619     char *p, *pn;
1620     unsigned int use;
1621
1622     if( !r )
1623         return 0; /* none (this is an optional parameter)*/
1624     
1625     use = 0;
1626     pn = r->u.value;
1627     while ( (p = strsep (&pn, " \t,")) ) {
1628         if ( !*p)
1629             ;
1630         else if ( !ascii_strcasecmp (p, "sign") )
1631             use |= PUBKEY_USAGE_SIG;
1632         else if ( !ascii_strcasecmp (p, "encrypt") )
1633             use |= PUBKEY_USAGE_ENC;
1634         else {
1635             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
1636             return -1; /* error */
1637         }
1638     }
1639     r->u.usage = use;
1640     return 0;
1641 }
1642
1643 static int
1644 parse_revocation_key (const char *fname,
1645                       struct para_data_s *para, enum para_name key)
1646 {
1647   struct para_data_s *r = get_parameter( para, key );
1648   struct revocation_key revkey;
1649   char *pn;
1650   int i;
1651
1652   if( !r )
1653     return 0; /* none (this is an optional parameter) */
1654
1655   pn = r->u.value;
1656
1657   revkey.class=0x80;
1658   revkey.algid=atoi(pn);
1659   if(!revkey.algid)
1660     goto fail;
1661
1662   /* Skip to the fpr */
1663   while(*pn && *pn!=':')
1664     pn++;
1665
1666   if(*pn!=':')
1667     goto fail;
1668
1669   pn++;
1670
1671   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
1672     {
1673       int c=hextobyte(pn);
1674       if(c==-1)
1675         goto fail;
1676
1677       revkey.fpr[i]=c;
1678     }
1679
1680   /* skip to the tag */
1681   while(*pn && *pn!='s' && *pn!='S')
1682     pn++;
1683
1684   if(ascii_strcasecmp(pn,"sensitive")==0)
1685     revkey.class|=0x40;
1686
1687   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
1688
1689   return 0;
1690
1691   fail:
1692   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
1693   return -1; /* error */
1694 }
1695
1696
1697 static u32
1698 get_parameter_u32( struct para_data_s *para, enum para_name key )
1699 {
1700     struct para_data_s *r = get_parameter( para, key );
1701
1702     if( !r )
1703         return 0;
1704     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
1705         return r->u.expire;
1706     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
1707         return r->u.usage;
1708
1709     return (unsigned int)strtoul( r->u.value, NULL, 10 );
1710 }
1711
1712 static unsigned int
1713 get_parameter_uint( struct para_data_s *para, enum para_name key )
1714 {
1715     return get_parameter_u32( para, key );
1716 }
1717
1718 static DEK *
1719 get_parameter_dek( struct para_data_s *para, enum para_name key )
1720 {
1721     struct para_data_s *r = get_parameter( para, key );
1722     return r? r->u.dek : NULL;
1723 }
1724
1725 static STRING2KEY *
1726 get_parameter_s2k( struct para_data_s *para, enum para_name key )
1727 {
1728     struct para_data_s *r = get_parameter( para, key );
1729     return r? r->u.s2k : NULL;
1730 }
1731
1732 static struct revocation_key *
1733 get_parameter_revkey( struct para_data_s *para, enum para_name key )
1734 {
1735     struct para_data_s *r = get_parameter( para, key );
1736     return r? &r->u.revkey : NULL;
1737 }
1738
1739 static int
1740 proc_parameter_file( struct para_data_s *para, const char *fname,
1741                      struct output_control_s *outctrl )
1742 {
1743     struct para_data_s *r;
1744     const char *s1, *s2, *s3;
1745     size_t n;
1746     char *p;
1747     int i;
1748
1749     /* check that we have all required parameters */
1750     assert( get_parameter( para, pKEYTYPE ) );
1751     i = get_parameter_algo( para, pKEYTYPE );
1752     if( i < 1 || check_pubkey_algo2( i, PUBKEY_USAGE_SIG ) ) {
1753         r = get_parameter( para, pKEYTYPE );
1754         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1755         return -1;
1756     }
1757
1758     if (parse_parameter_usage (fname, para, pKEYUSAGE))
1759         return -1;
1760
1761     i = get_parameter_algo( para, pSUBKEYTYPE );
1762     if( i > 0 && check_pubkey_algo( i ) ) {
1763         r = get_parameter( para, pSUBKEYTYPE );
1764         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1765         return -1;
1766     }
1767     if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
1768         return -1;
1769
1770
1771     if( !get_parameter_value( para, pUSERID ) ) {
1772         /* create the formatted user ID */
1773         s1 = get_parameter_value( para, pNAMEREAL );
1774         s2 = get_parameter_value( para, pNAMECOMMENT );
1775         s3 = get_parameter_value( para, pNAMEEMAIL );
1776         if( s1 || s2 || s3 ) {
1777             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
1778             r = m_alloc_clear( sizeof *r + n + 20 );
1779             r->key = pUSERID;
1780             p = r->u.value;
1781             if( s1 )
1782                 p = stpcpy(p, s1 );
1783             if( s2 )
1784                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
1785             if( s3 )
1786                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
1787             r->next = para;
1788             para = r;
1789         }
1790     }
1791
1792     /* Set preferences, if any. */
1793     keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
1794
1795     /* Set revoker, if any. */
1796     if (parse_revocation_key (fname, para, pREVOKER))
1797       return -1;
1798
1799     /* make DEK and S2K from the Passphrase */
1800     r = get_parameter( para, pPASSPHRASE );
1801     if( r && *r->u.value ) {
1802         /* we have a plain text passphrase - create a DEK from it.
1803          * It is a little bit ridiculous to keep it ih secure memory
1804          * but becuase we do this alwasy, why not here */
1805         STRING2KEY *s2k;
1806         DEK *dek;
1807
1808         s2k = m_alloc_secure( sizeof *s2k );
1809         s2k->mode = opt.s2k_mode;
1810         s2k->hash_algo = opt.s2k_digest_algo;
1811         set_next_passphrase( r->u.value );
1812         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2, NULL );
1813         set_next_passphrase( NULL );
1814         assert( dek );
1815         memset( r->u.value, 0, strlen(r->u.value) );
1816
1817         r = m_alloc_clear( sizeof *r );
1818         r->key = pPASSPHRASE_S2K;
1819         r->u.s2k = s2k;
1820         r->next = para;
1821         para = r;
1822         r = m_alloc_clear( sizeof *r );
1823         r->key = pPASSPHRASE_DEK;
1824         r->u.dek = dek;
1825         r->next = para;
1826         para = r;
1827     }
1828
1829     /* make KEYEXPIRE from Expire-Date */
1830     r = get_parameter( para, pEXPIREDATE );
1831     if( r && *r->u.value ) {
1832         i = parse_expire_string( r->u.value );
1833         if( i < 0 ) {
1834             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
1835             return -1;
1836         }
1837         r->u.expire = i * 86400L;
1838         r->key = pKEYEXPIRE;  /* change hat entry */
1839         /* also set it for the subkey */
1840         r = m_alloc_clear( sizeof *r + 20 );
1841         r->key = pSUBKEYEXPIRE;
1842         r->u.expire = i * 86400L;
1843         r->next = para;
1844         para = r;
1845     }
1846
1847     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
1848         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
1849         return -1;
1850     }
1851
1852     do_generate_keypair( para, outctrl );
1853     return 0;
1854 }
1855
1856
1857 /****************
1858  * Kludge to allow non interactive key generation controlled
1859  * by a parameter file (which currently is only stdin)
1860  * Note, that string parameters are expected to be in UTF-8
1861  */
1862 static void
1863 read_parameter_file( const char *fname )
1864 {
1865     static struct { const char *name;
1866                     enum para_name key;
1867     } keywords[] = {
1868         { "Key-Type",       pKEYTYPE},
1869         { "Key-Length",     pKEYLENGTH },
1870         { "Key-Usage",      pKEYUSAGE },
1871         { "Subkey-Type",    pSUBKEYTYPE },
1872         { "Subkey-Length",  pSUBKEYLENGTH },
1873         { "Subkey-Usage",   pSUBKEYUSAGE },
1874         { "Name-Real",      pNAMEREAL },
1875         { "Name-Email",     pNAMEEMAIL },
1876         { "Name-Comment",   pNAMECOMMENT },
1877         { "Expire-Date",    pEXPIREDATE },
1878         { "Passphrase",     pPASSPHRASE },
1879         { "Preferences",    pPREFERENCES },
1880         { "Revoker",        pREVOKER },
1881         { NULL, 0 }
1882     };
1883     FILE *fp;
1884     char line[1024], *p;
1885     int lnr;
1886     const char *err = NULL;
1887     struct para_data_s *para, *r;
1888     int i;
1889     struct output_control_s outctrl;
1890
1891     memset( &outctrl, 0, sizeof( outctrl ) );
1892
1893     if( !fname || !*fname || !strcmp(fname,"-") ) {
1894         fp = stdin;
1895         fname = "-";
1896     }
1897     else {
1898         fp = fopen( fname, "r" );
1899         if( !fp ) {
1900             log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
1901             return;
1902         }
1903     }
1904
1905     lnr = 0;
1906     err = NULL;
1907     para = NULL;
1908     while( fgets( line, DIM(line)-1, fp ) ) {
1909         char *keyword, *value;
1910
1911         lnr++;
1912         if( *line && line[strlen(line)-1] != '\n' ) {
1913             err = "line too long";
1914             break;
1915         }
1916         for( p = line; isspace(*(byte*)p); p++ )
1917             ;
1918         if( !*p || *p == '#' )
1919             continue;
1920         keyword = p;
1921         if( *keyword == '%' ) {
1922             for( ; !isspace(*(byte*)p); p++ )
1923                 ;
1924             if( *p )
1925                 *p++ = 0;
1926             for( ; isspace(*(byte*)p); p++ )
1927                 ;
1928             value = p;
1929             trim_trailing_ws( value, strlen(value) );
1930             if( !ascii_strcasecmp( keyword, "%echo" ) )
1931                 log_info("%s\n", value );
1932             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
1933                 outctrl.dryrun = 1;
1934             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
1935                 outctrl.lnr = lnr;
1936                 proc_parameter_file( para, fname, &outctrl );
1937                 release_parameter_list( para );
1938                 para = NULL;
1939             }
1940             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
1941                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
1942                     ; /* still the same file - ignore it */
1943                 else {
1944                     m_free( outctrl.pub.newfname );
1945                     outctrl.pub.newfname = m_strdup( value );
1946                     outctrl.use_files = 1;
1947                 }
1948             }
1949             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
1950                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
1951                     ; /* still the same file - ignore it */
1952                 else {
1953                    m_free( outctrl.sec.newfname );
1954                    outctrl.sec.newfname = m_strdup( value );
1955                    outctrl.use_files = 1;
1956                 }
1957             }
1958             else
1959                 log_info("skipping control `%s' (%s)\n", keyword, value );
1960
1961
1962             continue;
1963         }
1964
1965
1966         if( !(p = strchr( p, ':' )) || p == keyword ) {
1967             err = "missing colon";
1968             break;
1969         }
1970         if( *p )
1971             *p++ = 0;
1972         for( ; isspace(*(byte*)p); p++ )
1973             ;
1974         if( !*p ) {
1975             err = "missing argument";
1976             break;
1977         }
1978         value = p;
1979         trim_trailing_ws( value, strlen(value) );
1980
1981         for(i=0; keywords[i].name; i++ ) {
1982             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
1983                 break;
1984         }
1985         if( !keywords[i].name ) {
1986             err = "unknown keyword";
1987             break;
1988         }
1989         if( keywords[i].key != pKEYTYPE && !para ) {
1990             err = "parameter block does not start with \"Key-Type\"";
1991             break;
1992         }
1993
1994         if( keywords[i].key == pKEYTYPE && para ) {
1995             outctrl.lnr = lnr;
1996             proc_parameter_file( para, fname, &outctrl );
1997             release_parameter_list( para );
1998             para = NULL;
1999         }
2000         else {
2001             for( r = para; r; r = r->next ) {
2002                 if( r->key == keywords[i].key )
2003                     break;
2004             }
2005             if( r ) {
2006                 err = "duplicate keyword";
2007                 break;
2008             }
2009         }
2010         r = m_alloc_clear( sizeof *r + strlen( value ) );
2011         r->lnr = lnr;
2012         r->key = keywords[i].key;
2013         strcpy( r->u.value, value );
2014         r->next = para;
2015         para = r;
2016     }
2017     if( err )
2018         log_error("%s:%d: %s\n", fname, lnr, err );
2019     else if( ferror(fp) ) {
2020         log_error("%s:%d: read error: %s\n", fname, lnr, strerror(errno) );
2021     }
2022     else if( para ) {
2023         outctrl.lnr = lnr;
2024         proc_parameter_file( para, fname, &outctrl );
2025     }
2026
2027     if( outctrl.use_files ) { /* close open streams */
2028         iobuf_close( outctrl.pub.stream );
2029         iobuf_close( outctrl.sec.stream );
2030         m_free( outctrl.pub.fname );
2031         m_free( outctrl.pub.newfname );
2032         m_free( outctrl.sec.fname );
2033         m_free( outctrl.sec.newfname );
2034     }
2035
2036     release_parameter_list( para );
2037     if( strcmp( fname, "-" ) )
2038         fclose(fp);
2039 }
2040
2041
2042 /****************
2043  * Generate a keypair
2044  * (fname is only used in batch mode)
2045  */
2046 void
2047 generate_keypair( const char *fname )
2048 {
2049     unsigned int nbits;
2050     char *uid = NULL;
2051     DEK *dek;
2052     STRING2KEY *s2k;
2053     int algo;
2054     unsigned int use;
2055     int both = 0;
2056     u32 expire;
2057     struct para_data_s *para = NULL;
2058     struct para_data_s *r;
2059     struct output_control_s outctrl;
2060
2061     memset( &outctrl, 0, sizeof( outctrl ) );
2062
2063     if( opt.batch ) {
2064         read_parameter_file( fname );
2065         return;
2066     }
2067
2068     algo = ask_algo( 0, &use );
2069     if( !algo ) { /* default: DSA with ElG subkey of the specified size */
2070         both = 1;
2071         r = m_alloc_clear( sizeof *r + 20 );
2072         r->key = pKEYTYPE;
2073         sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2074         r->next = para;
2075         para = r;
2076         tty_printf(_("DSA keypair will have 1024 bits.\n"));
2077         r = m_alloc_clear( sizeof *r + 20 );
2078         r->key = pKEYLENGTH;
2079         strcpy( r->u.value, "1024" );
2080         r->next = para;
2081         para = r;
2082
2083         algo = PUBKEY_ALGO_ELGAMAL_E;
2084         r = m_alloc_clear( sizeof *r + 20 );
2085         r->key = pSUBKEYTYPE;
2086         sprintf( r->u.value, "%d", algo );
2087         r->next = para;
2088         para = r;
2089     }
2090     else {
2091         r = m_alloc_clear( sizeof *r + 20 );
2092         r->key = pKEYTYPE;
2093         sprintf( r->u.value, "%d", algo );
2094         r->next = para;
2095         para = r;
2096
2097         if (use) {
2098             r = m_alloc_clear( sizeof *r + 20 );
2099             r->key = pKEYUSAGE;
2100             sprintf( r->u.value, "%s%s",
2101                      (use & PUBKEY_USAGE_SIG)? "sign ":"",
2102                      (use & PUBKEY_USAGE_ENC)? "encrypt ":"" );
2103             r->next = para;
2104             para = r;
2105         }
2106
2107     }
2108
2109     nbits = ask_keysize( algo );
2110     r = m_alloc_clear( sizeof *r + 20 );
2111     r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2112     sprintf( r->u.value, "%u", nbits);
2113     r->next = para;
2114     para = r;
2115
2116     expire = ask_expire_interval(0);
2117     r = m_alloc_clear( sizeof *r + 20 );
2118     r->key = pKEYEXPIRE;
2119     r->u.expire = expire;
2120     r->next = para;
2121     para = r;
2122     r = m_alloc_clear( sizeof *r + 20 );
2123     r->key = pSUBKEYEXPIRE;
2124     r->u.expire = expire;
2125     r->next = para;
2126     para = r;
2127
2128     uid = ask_user_id(0);
2129     if( !uid ) {
2130         log_error(_("Key generation canceled.\n"));
2131         release_parameter_list( para );
2132         return;
2133     }
2134     r = m_alloc_clear( sizeof *r + strlen(uid) );
2135     r->key = pUSERID;
2136     strcpy( r->u.value, uid );
2137     r->next = para;
2138     para = r;
2139
2140     dek = ask_passphrase( &s2k );
2141     if( dek ) {
2142         r = m_alloc_clear( sizeof *r );
2143         r->key = pPASSPHRASE_DEK;
2144         r->u.dek = dek;
2145         r->next = para;
2146         para = r;
2147         r = m_alloc_clear( sizeof *r );
2148         r->key = pPASSPHRASE_S2K;
2149         r->u.s2k = s2k;
2150         r->next = para;
2151         para = r;
2152     }
2153
2154     proc_parameter_file( para, "[internal]", &outctrl );
2155     release_parameter_list( para );
2156 }
2157
2158
2159 static void
2160 print_status_key_created (int letter, PKT_public_key *pk)
2161 {
2162   byte array[MAX_FINGERPRINT_LEN], *s;
2163   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
2164   size_t i, n;
2165   
2166   p = buf;
2167   *p++ = letter;
2168   *p++ = ' ';
2169   fingerprint_from_pk (pk, array, &n);
2170   s = array;
2171   for (i=0; i < n ; i++, s++, p += 2)
2172     sprintf (p, "%02X", *s);
2173   *p = 0;
2174   write_status_text (STATUS_KEY_CREATED, buf);
2175 }
2176
2177 static void
2178 do_generate_keypair( struct para_data_s *para,
2179                      struct output_control_s *outctrl )
2180 {
2181     KBNODE pub_root = NULL;
2182     KBNODE sec_root = NULL;
2183     PKT_secret_key *sk = NULL;
2184     const char *s;
2185     struct revocation_key *revkey;
2186     int rc;
2187     int did_sub = 0;
2188
2189     if( outctrl->dryrun ) {
2190         log_info("dry-run mode - key generation skipped\n");
2191         return;
2192     }
2193
2194
2195     if( outctrl->use_files ) {
2196         if( outctrl->pub.newfname ) {
2197             iobuf_close(outctrl->pub.stream);
2198             outctrl->pub.stream = NULL;
2199             m_free( outctrl->pub.fname );
2200             outctrl->pub.fname =  outctrl->pub.newfname;
2201             outctrl->pub.newfname = NULL;
2202
2203             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
2204             if( !outctrl->pub.stream ) {
2205                 log_error("can't create `%s': %s\n", outctrl->pub.newfname,
2206                                                      strerror(errno) );
2207                 return;
2208             }
2209             if( opt.armor ) {
2210                 outctrl->pub.afx.what = 1;
2211                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
2212                                                     &outctrl->pub.afx );
2213             }
2214         }
2215         if( outctrl->sec.newfname ) {
2216             iobuf_close(outctrl->sec.stream);
2217             outctrl->sec.stream = NULL;
2218             m_free( outctrl->sec.fname );
2219             outctrl->sec.fname =  outctrl->sec.newfname;
2220             outctrl->sec.newfname = NULL;
2221
2222             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
2223             if( !outctrl->sec.stream ) {
2224                 log_error("can't create `%s': %s\n", outctrl->sec.newfname,
2225                                                      strerror(errno) );
2226                 return;
2227             }
2228             if( opt.armor ) {
2229                 outctrl->sec.afx.what = 5;
2230                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
2231                                                     &outctrl->sec.afx );
2232             }
2233         }
2234         assert( outctrl->pub.stream );
2235         assert( outctrl->sec.stream );
2236         if( opt.verbose ) {
2237             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
2238             log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
2239         }
2240     }
2241
2242
2243     /* we create the packets as a tree of kbnodes. Because the structure
2244      * we create is known in advance we simply generate a linked list
2245      * The first packet is a dummy comment packet which we flag
2246      * as deleted.  The very first packet must always be a KEY packet.
2247      */
2248     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
2249     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
2250
2251     rc = do_create( get_parameter_algo( para, pKEYTYPE ),
2252                     get_parameter_uint( para, pKEYLENGTH ),
2253                     pub_root, sec_root,
2254                     get_parameter_dek( para, pPASSPHRASE_DEK ),
2255                     get_parameter_s2k( para, pPASSPHRASE_S2K ),
2256                     &sk,
2257                     get_parameter_u32( para, pKEYEXPIRE ) );
2258
2259     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
2260       {
2261         rc=write_direct_sig(pub_root,pub_root,sk,revkey);
2262         if(!rc)
2263           write_direct_sig(sec_root,pub_root,sk,revkey);
2264       }
2265
2266     if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
2267         write_uid(pub_root, s );
2268         if( !rc )
2269             write_uid(sec_root, s );
2270         if( !rc )
2271             rc = write_selfsig(pub_root, pub_root, sk,
2272                                get_parameter_uint (para, pKEYUSAGE));
2273         if( !rc )
2274             rc = write_selfsig(sec_root, pub_root, sk,
2275                                get_parameter_uint (para, pKEYUSAGE));
2276     }
2277
2278     if( get_parameter( para, pSUBKEYTYPE ) ) {
2279         rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
2280                         get_parameter_uint( para, pSUBKEYLENGTH ),
2281                         pub_root, sec_root,
2282                         get_parameter_dek( para, pPASSPHRASE_DEK ),
2283                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
2284                         NULL,
2285                         get_parameter_u32( para, pSUBKEYEXPIRE ) );
2286         if( !rc )
2287             rc = write_keybinding(pub_root, pub_root, sk,
2288                                   get_parameter_uint (para, pSUBKEYUSAGE));
2289         if( !rc )
2290             rc = write_keybinding(sec_root, pub_root, sk,
2291                                   get_parameter_uint (para, pSUBKEYUSAGE));
2292         did_sub = 1;
2293     }
2294
2295
2296     if( !rc && outctrl->use_files ) { /* direct write to specified files */
2297         rc = write_keyblock( outctrl->pub.stream, pub_root );
2298         if( rc )
2299             log_error("can't write public key: %s\n", g10_errstr(rc) );
2300         if( !rc ) {
2301             rc = write_keyblock( outctrl->sec.stream, sec_root );
2302             if( rc )
2303                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
2304         }
2305
2306     }
2307     else if( !rc ) { /* write to the standard keyrings */
2308         KEYDB_HANDLE pub_hd = keydb_new (0);
2309         KEYDB_HANDLE sec_hd = keydb_new (1);
2310
2311         /* FIXME: we may have to create the keyring first */
2312         rc = keydb_locate_writable (pub_hd, NULL);
2313         if (rc) 
2314             log_error (_("no writable public keyring found: %s\n"),
2315                        g10_errstr (rc));
2316
2317         if (!rc) {  
2318             rc = keydb_locate_writable (sec_hd, NULL);
2319             if (rc) 
2320                 log_error (_("no writable secret keyring found: %s\n"),
2321                            g10_errstr (rc));
2322         }
2323
2324         if (!rc && opt.verbose) {
2325             log_info(_("writing public key to `%s'\n"),
2326                      keydb_get_resource_name (pub_hd));
2327             log_info(_("writing secret key to `%s'\n"),
2328                      keydb_get_resource_name (sec_hd));
2329         }
2330
2331         if (!rc) {
2332             rc = keydb_insert_keyblock (pub_hd, pub_root);
2333             if (rc)
2334                 log_error (_("error writing public keyring `%s': %s\n"),
2335                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2336         }
2337
2338         if (!rc) {
2339             rc = keydb_insert_keyblock (sec_hd, sec_root);
2340             if (rc)
2341                 log_error (_("error writing secret keyring `%s': %s\n"),
2342                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2343         }
2344
2345         keydb_release (pub_hd);
2346         keydb_release (sec_hd);
2347
2348         if (!rc) {
2349             int no_enc_rsa =
2350                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
2351                 && get_parameter_uint( para, pKEYUSAGE )
2352                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
2353             PKT_public_key *pk = find_kbnode (pub_root, 
2354                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2355             
2356             update_ownertrust (pk,
2357                                ((get_ownertrust (pk) & ~TRUST_MASK)
2358                                 | TRUST_ULTIMATE ));
2359
2360             if (!opt.batch) {
2361                 tty_printf(_("public and secret key created and signed.\n") );
2362                 tty_printf(_("key marked as ultimately trusted.\n") );
2363                 tty_printf("\n");
2364                 list_keyblock(pub_root,0,1,NULL);
2365             }
2366             
2367
2368             if( !opt.batch
2369                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
2370                      || no_enc_rsa )
2371                 && !get_parameter( para, pSUBKEYTYPE ) )
2372             {
2373                 tty_printf(_("Note that this key cannot be used for "
2374                              "encryption.  You may want to use\n"
2375                              "the command \"--edit-key\" to generate a "
2376                              "secondary key for this purpose.\n") );
2377             }
2378         }
2379     }
2380
2381     if( rc ) {
2382         if( opt.batch )
2383             log_error("key generation failed: %s\n", g10_errstr(rc) );
2384         else
2385             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
2386     }
2387     else {
2388         PKT_public_key *pk = find_kbnode (pub_root, 
2389                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2390         print_status_key_created (did_sub? 'B':'P', pk);
2391     }
2392     release_kbnode( pub_root );
2393     release_kbnode( sec_root );
2394     if( sk ) /* the unprotected  secret key */
2395         free_secret_key(sk);
2396 }
2397
2398
2399 /****************
2400  * add a new subkey to an existing key.
2401  * Returns true if a new key has been generated and put into the keyblocks.
2402  */
2403 int
2404 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
2405 {
2406     int okay=0, rc=0;
2407     KBNODE node;
2408     PKT_secret_key *sk = NULL; /* this is the primary sk */
2409     int algo;
2410     unsigned int use;
2411     u32 expire;
2412     unsigned nbits;
2413     char *passphrase = NULL;
2414     DEK *dek = NULL;
2415     STRING2KEY *s2k = NULL;
2416     u32 cur_time;
2417
2418     /* break out the primary secret key */
2419     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
2420     if( !node ) {
2421         log_error("Oops; secret key not found anymore!\n");
2422         goto leave;
2423     }
2424
2425     /* make a copy of the sk to keep the protected one in the keyblock */
2426     sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
2427
2428     cur_time = make_timestamp();
2429     if( sk->timestamp > cur_time ) {
2430         ulong d = sk->timestamp - cur_time;
2431         log_info( d==1 ? _("key has been created %lu second "
2432                            "in future (time warp or clock problem)\n")
2433                        : _("key has been created %lu seconds "
2434                            "in future (time warp or clock problem)\n"), d );
2435         if( !opt.ignore_time_conflict ) {
2436             rc = G10ERR_TIME_CONFLICT;
2437             goto leave;
2438         }
2439     }
2440
2441     if (sk->version < 4) {
2442         log_info (_("NOTE: creating subkeys for v3 keys "
2443                     "is not OpenPGP compliant\n"));
2444         goto leave;
2445     }
2446
2447     /* unprotect to get the passphrase */
2448     switch( is_secret_key_protected( sk ) ) {
2449       case -1:
2450         rc = G10ERR_PUBKEY_ALGO;
2451         break;
2452       case 0:
2453         tty_printf("This key is not protected.\n");
2454         break;
2455       default:
2456         tty_printf("Key is protected.\n");
2457         rc = check_secret_key( sk, 0 );
2458         if( !rc )
2459             passphrase = get_last_passphrase();
2460         break;
2461     }
2462     if( rc )
2463         goto leave;
2464
2465
2466     algo = ask_algo( 1, &use );
2467     assert(algo);
2468     nbits = ask_keysize( algo );
2469     expire = ask_expire_interval(0);
2470     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
2471                                                   _("Really create? ") ) )
2472         goto leave;
2473
2474     if( passphrase ) {
2475         s2k = m_alloc_secure( sizeof *s2k );
2476         s2k->mode = opt.s2k_mode;
2477         s2k->hash_algo = opt.s2k_digest_algo;
2478         set_next_passphrase( passphrase );
2479         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2, NULL );
2480     }
2481
2482     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
2483                                       dek, s2k, NULL, expire );
2484     if( !rc )
2485         rc = write_keybinding(pub_keyblock, pub_keyblock, sk, use);
2486     if( !rc )
2487         rc = write_keybinding(sec_keyblock, pub_keyblock, sk, use);
2488     if( !rc ) {
2489         okay = 1;
2490         write_status_text (STATUS_KEY_CREATED, "S");
2491     }
2492
2493   leave:
2494     if( rc )
2495         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
2496     m_free( passphrase );
2497     m_free( dek );
2498     m_free( s2k );
2499     if( sk ) /* release the copy of the (now unprotected) secret key */
2500         free_secret_key(sk);
2501     set_next_passphrase( NULL );
2502     return okay;
2503 }
2504
2505 /****************
2506  * Write a keyblock to an output stream
2507  */
2508 static int
2509 write_keyblock( IOBUF out, KBNODE node )
2510 {
2511     for( ; node ; node = node->next ) {
2512         int rc = build_packet( out, node->pkt );
2513         if( rc ) {
2514             log_error("build_packet(%d) failed: %s\n",
2515                         node->pkt->pkttype, g10_errstr(rc) );
2516             return G10ERR_WRITE_FILE;
2517         }
2518     }
2519     return 0;
2520 }