* parse-packet.c (parse_signature): No need to reserve 8 bytes for the
[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 "S9 S8 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( !digitp(s) )
997         return 0;
998     for( s++; *s; s++)
999         if( !digitp(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( digitp(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 || opt.allow_freeform_uid )
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 && !opt.allow_freeform_uid
1401             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1402             fail = 1;
1403             tty_printf(_("Please don't put the email address "
1404                           "into the real name or the comment\n") );
1405         }
1406
1407         for(;;) {
1408             const char *ansstr = _("NnCcEeOoQq");
1409
1410             if( strlen(ansstr) != 10 )
1411                 BUG();
1412             if( cpr_enabled() ) {
1413                 answer = m_strdup(ansstr+6);
1414                 answer[1] = 0;
1415             }
1416             else {
1417                 answer = cpr_get("keygen.userid.cmd", fail?
1418                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1419                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1420                 cpr_kill_prompt();
1421             }
1422             if( strlen(answer) > 1 )
1423                 ;
1424             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1425                 m_free(aname); aname = NULL;
1426                 break;
1427             }
1428             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1429                 m_free(acomment); acomment = NULL;
1430                 break;
1431             }
1432             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1433                 m_free(amail); amail = NULL;
1434                 break;
1435             }
1436             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1437                 if( fail ) {
1438                     tty_printf(_("Please correct the error first\n"));
1439                 }
1440                 else {
1441                     m_free(aname); aname = NULL;
1442                     m_free(acomment); acomment = NULL;
1443                     m_free(amail); amail = NULL;
1444                     break;
1445                 }
1446             }
1447             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1448                 m_free(aname); aname = NULL;
1449                 m_free(acomment); acomment = NULL;
1450                 m_free(amail); amail = NULL;
1451                 m_free(uid); uid = NULL;
1452                 break;
1453             }
1454             m_free(answer);
1455         }
1456         m_free(answer);
1457         if( !amail && !acomment && !amail )
1458             break;
1459         m_free(uid); uid = NULL;
1460     }
1461     if( uid ) {
1462         char *p = native_to_utf8( uid );
1463         m_free( uid );
1464         uid = p;
1465     }
1466     return uid;
1467 }
1468
1469
1470 static DEK *
1471 ask_passphrase( STRING2KEY **ret_s2k )
1472 {
1473     DEK *dek = NULL;
1474     STRING2KEY *s2k;
1475     const char *errtext = NULL;
1476
1477     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1478
1479     s2k = m_alloc_secure( sizeof *s2k );
1480     for(;;) {
1481         s2k->mode = opt.s2k_mode;
1482         s2k->hash_algo = opt.s2k_digest_algo;
1483         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
1484                                  errtext, NULL);
1485         if( !dek ) {
1486             errtext = N_("passphrase not correctly repeated; try again");
1487             tty_printf(_("%s.\n"), _(errtext));
1488         }
1489         else if( !dek->keylen ) {
1490             m_free(dek); dek = NULL;
1491             m_free(s2k); s2k = NULL;
1492             tty_printf(_(
1493             "You don't want a passphrase - this is probably a *bad* idea!\n"
1494             "I will do it anyway.  You can change your passphrase at any time,\n"
1495             "using this program with the option \"--edit-key\".\n\n"));
1496             break;
1497         }
1498         else
1499             break; /* okay */
1500     }
1501     *ret_s2k = s2k;
1502     return dek;
1503 }
1504
1505
1506 static int
1507 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
1508            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate )
1509 {
1510     int rc=0;
1511
1512     if( !opt.batch )
1513         tty_printf(_(
1514 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1515 "some other action (type on the keyboard, move the mouse, utilize the\n"
1516 "disks) during the prime generation; this gives the random number\n"
1517 "generator a better chance to gain enough entropy.\n") );
1518
1519     if( algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E )
1520         rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1521     else if( algo == PUBKEY_ALGO_DSA )
1522         rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1523     else if( algo == PUBKEY_ALGO_RSA )
1524         rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1525     else
1526         BUG();
1527
1528 #ifdef ENABLE_COMMENT_PACKETS
1529     if( !rc ) {
1530         add_kbnode( pub_root,
1531                 make_comment_node("#created by GNUPG v" VERSION " ("
1532                                             PRINTABLE_OS_NAME ")"));
1533         add_kbnode( sec_root,
1534                 make_comment_node("#created by GNUPG v" VERSION " ("
1535                                             PRINTABLE_OS_NAME ")"));
1536     }
1537 #endif
1538     return rc;
1539 }
1540
1541
1542 /****************
1543  * Generate a new user id packet, or return NULL if canceled
1544  */
1545 PKT_user_id *
1546 generate_user_id()
1547 {
1548     PKT_user_id *uid;
1549     char *p;
1550     size_t n;
1551
1552     p = ask_user_id( 1 );
1553     if( !p )
1554         return NULL;
1555     n = strlen(p);
1556     uid = m_alloc_clear( sizeof *uid + n - 1 );
1557     uid->len = n;
1558     strcpy(uid->name, p);
1559     uid->ref = 1;
1560     return uid;
1561 }
1562
1563
1564 static void
1565 release_parameter_list( struct para_data_s *r )
1566 {
1567     struct para_data_s *r2;
1568
1569     for( ; r ; r = r2 ) {
1570         r2 = r->next;
1571         if( r->key == pPASSPHRASE_DEK )
1572             m_free( r->u.dek );
1573         else if( r->key == pPASSPHRASE_S2K )
1574             m_free( r->u.s2k );
1575
1576         m_free(r);
1577     }
1578 }
1579
1580 static struct para_data_s *
1581 get_parameter( struct para_data_s *para, enum para_name key )
1582 {
1583     struct para_data_s *r;
1584
1585     for( r = para; r && r->key != key; r = r->next )
1586         ;
1587     return r;
1588 }
1589
1590 static const char *
1591 get_parameter_value( struct para_data_s *para, enum para_name key )
1592 {
1593     struct para_data_s *r = get_parameter( para, key );
1594     return (r && *r->u.value)? r->u.value : NULL;
1595 }
1596
1597 static int
1598 get_parameter_algo( struct para_data_s *para, enum para_name key )
1599 {
1600     int i;
1601     struct para_data_s *r = get_parameter( para, key );
1602     if( !r )
1603         return -1;
1604     if( digitp( r->u.value ) )
1605         i = atoi( r->u.value );
1606     else
1607         i = string_to_pubkey_algo( r->u.value );
1608     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
1609       i = 0; /* we don't want to allow generation of these algorithms */
1610     return i;
1611 }
1612
1613 /* 
1614  * parse the usage parameter and set the keyflags.  Return true on error.
1615  */
1616 static int
1617 parse_parameter_usage (const char *fname,
1618                        struct para_data_s *para, enum para_name key)
1619 {
1620     struct para_data_s *r = get_parameter( para, key );
1621     char *p, *pn;
1622     unsigned int use;
1623
1624     if( !r )
1625         return 0; /* none (this is an optional parameter)*/
1626     
1627     use = 0;
1628     pn = r->u.value;
1629     while ( (p = strsep (&pn, " \t,")) ) {
1630         if ( !*p)
1631             ;
1632         else if ( !ascii_strcasecmp (p, "sign") )
1633             use |= PUBKEY_USAGE_SIG;
1634         else if ( !ascii_strcasecmp (p, "encrypt") )
1635             use |= PUBKEY_USAGE_ENC;
1636         else {
1637             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
1638             return -1; /* error */
1639         }
1640     }
1641     r->u.usage = use;
1642     return 0;
1643 }
1644
1645 static int
1646 parse_revocation_key (const char *fname,
1647                       struct para_data_s *para, enum para_name key)
1648 {
1649   struct para_data_s *r = get_parameter( para, key );
1650   struct revocation_key revkey;
1651   char *pn;
1652   int i;
1653
1654   if( !r )
1655     return 0; /* none (this is an optional parameter) */
1656
1657   pn = r->u.value;
1658
1659   revkey.class=0x80;
1660   revkey.algid=atoi(pn);
1661   if(!revkey.algid)
1662     goto fail;
1663
1664   /* Skip to the fpr */
1665   while(*pn && *pn!=':')
1666     pn++;
1667
1668   if(*pn!=':')
1669     goto fail;
1670
1671   pn++;
1672
1673   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
1674     {
1675       int c=hextobyte(pn);
1676       if(c==-1)
1677         goto fail;
1678
1679       revkey.fpr[i]=c;
1680     }
1681
1682   /* skip to the tag */
1683   while(*pn && *pn!='s' && *pn!='S')
1684     pn++;
1685
1686   if(ascii_strcasecmp(pn,"sensitive")==0)
1687     revkey.class|=0x40;
1688
1689   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
1690
1691   return 0;
1692
1693   fail:
1694   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
1695   return -1; /* error */
1696 }
1697
1698
1699 static u32
1700 get_parameter_u32( struct para_data_s *para, enum para_name key )
1701 {
1702     struct para_data_s *r = get_parameter( para, key );
1703
1704     if( !r )
1705         return 0;
1706     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
1707         return r->u.expire;
1708     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
1709         return r->u.usage;
1710
1711     return (unsigned int)strtoul( r->u.value, NULL, 10 );
1712 }
1713
1714 static unsigned int
1715 get_parameter_uint( struct para_data_s *para, enum para_name key )
1716 {
1717     return get_parameter_u32( para, key );
1718 }
1719
1720 static DEK *
1721 get_parameter_dek( struct para_data_s *para, enum para_name key )
1722 {
1723     struct para_data_s *r = get_parameter( para, key );
1724     return r? r->u.dek : NULL;
1725 }
1726
1727 static STRING2KEY *
1728 get_parameter_s2k( struct para_data_s *para, enum para_name key )
1729 {
1730     struct para_data_s *r = get_parameter( para, key );
1731     return r? r->u.s2k : NULL;
1732 }
1733
1734 static struct revocation_key *
1735 get_parameter_revkey( struct para_data_s *para, enum para_name key )
1736 {
1737     struct para_data_s *r = get_parameter( para, key );
1738     return r? &r->u.revkey : NULL;
1739 }
1740
1741 static int
1742 proc_parameter_file( struct para_data_s *para, const char *fname,
1743                      struct output_control_s *outctrl )
1744 {
1745     struct para_data_s *r;
1746     const char *s1, *s2, *s3;
1747     size_t n;
1748     char *p;
1749     int i;
1750
1751     /* check that we have all required parameters */
1752     assert( get_parameter( para, pKEYTYPE ) );
1753     i = get_parameter_algo( para, pKEYTYPE );
1754     if( i < 1 || check_pubkey_algo2( i, PUBKEY_USAGE_SIG ) ) {
1755         r = get_parameter( para, pKEYTYPE );
1756         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1757         return -1;
1758     }
1759
1760     if (parse_parameter_usage (fname, para, pKEYUSAGE))
1761         return -1;
1762
1763     i = get_parameter_algo( para, pSUBKEYTYPE );
1764     if( i > 0 && check_pubkey_algo( i ) ) {
1765         r = get_parameter( para, pSUBKEYTYPE );
1766         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1767         return -1;
1768     }
1769     if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
1770         return -1;
1771
1772
1773     if( !get_parameter_value( para, pUSERID ) ) {
1774         /* create the formatted user ID */
1775         s1 = get_parameter_value( para, pNAMEREAL );
1776         s2 = get_parameter_value( para, pNAMECOMMENT );
1777         s3 = get_parameter_value( para, pNAMEEMAIL );
1778         if( s1 || s2 || s3 ) {
1779             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
1780             r = m_alloc_clear( sizeof *r + n + 20 );
1781             r->key = pUSERID;
1782             p = r->u.value;
1783             if( s1 )
1784                 p = stpcpy(p, s1 );
1785             if( s2 )
1786                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
1787             if( s3 )
1788                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
1789             r->next = para;
1790             para = r;
1791         }
1792     }
1793
1794     /* Set preferences, if any. */
1795     keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
1796
1797     /* Set revoker, if any. */
1798     if (parse_revocation_key (fname, para, pREVOKER))
1799       return -1;
1800
1801     /* make DEK and S2K from the Passphrase */
1802     r = get_parameter( para, pPASSPHRASE );
1803     if( r && *r->u.value ) {
1804         /* we have a plain text passphrase - create a DEK from it.
1805          * It is a little bit ridiculous to keep it ih secure memory
1806          * but becuase we do this alwasy, why not here */
1807         STRING2KEY *s2k;
1808         DEK *dek;
1809
1810         s2k = m_alloc_secure( sizeof *s2k );
1811         s2k->mode = opt.s2k_mode;
1812         s2k->hash_algo = opt.s2k_digest_algo;
1813         set_next_passphrase( r->u.value );
1814         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
1815                                  NULL, NULL);
1816         set_next_passphrase( NULL );
1817         assert( dek );
1818         memset( r->u.value, 0, strlen(r->u.value) );
1819
1820         r = m_alloc_clear( sizeof *r );
1821         r->key = pPASSPHRASE_S2K;
1822         r->u.s2k = s2k;
1823         r->next = para;
1824         para = r;
1825         r = m_alloc_clear( sizeof *r );
1826         r->key = pPASSPHRASE_DEK;
1827         r->u.dek = dek;
1828         r->next = para;
1829         para = r;
1830     }
1831
1832     /* make KEYEXPIRE from Expire-Date */
1833     r = get_parameter( para, pEXPIREDATE );
1834     if( r && *r->u.value ) {
1835         i = parse_expire_string( r->u.value );
1836         if( i < 0 ) {
1837             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
1838             return -1;
1839         }
1840         r->u.expire = i * 86400L;
1841         r->key = pKEYEXPIRE;  /* change hat entry */
1842         /* also set it for the subkey */
1843         r = m_alloc_clear( sizeof *r + 20 );
1844         r->key = pSUBKEYEXPIRE;
1845         r->u.expire = i * 86400L;
1846         r->next = para;
1847         para = r;
1848     }
1849
1850     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
1851         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
1852         return -1;
1853     }
1854
1855     do_generate_keypair( para, outctrl );
1856     return 0;
1857 }
1858
1859
1860 /****************
1861  * Kludge to allow non interactive key generation controlled
1862  * by a parameter file (which currently is only stdin)
1863  * Note, that string parameters are expected to be in UTF-8
1864  */
1865 static void
1866 read_parameter_file( const char *fname )
1867 {
1868     static struct { const char *name;
1869                     enum para_name key;
1870     } keywords[] = {
1871         { "Key-Type",       pKEYTYPE},
1872         { "Key-Length",     pKEYLENGTH },
1873         { "Key-Usage",      pKEYUSAGE },
1874         { "Subkey-Type",    pSUBKEYTYPE },
1875         { "Subkey-Length",  pSUBKEYLENGTH },
1876         { "Subkey-Usage",   pSUBKEYUSAGE },
1877         { "Name-Real",      pNAMEREAL },
1878         { "Name-Email",     pNAMEEMAIL },
1879         { "Name-Comment",   pNAMECOMMENT },
1880         { "Expire-Date",    pEXPIREDATE },
1881         { "Passphrase",     pPASSPHRASE },
1882         { "Preferences",    pPREFERENCES },
1883         { "Revoker",        pREVOKER },
1884         { NULL, 0 }
1885     };
1886     FILE *fp;
1887     char line[1024], *p;
1888     int lnr;
1889     const char *err = NULL;
1890     struct para_data_s *para, *r;
1891     int i;
1892     struct output_control_s outctrl;
1893
1894     memset( &outctrl, 0, sizeof( outctrl ) );
1895
1896     if( !fname || !*fname || !strcmp(fname,"-") ) {
1897         fp = stdin;
1898         fname = "-";
1899     }
1900     else {
1901         fp = fopen( fname, "r" );
1902         if( !fp ) {
1903             log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
1904             return;
1905         }
1906     }
1907
1908     lnr = 0;
1909     err = NULL;
1910     para = NULL;
1911     while( fgets( line, DIM(line)-1, fp ) ) {
1912         char *keyword, *value;
1913
1914         lnr++;
1915         if( *line && line[strlen(line)-1] != '\n' ) {
1916             err = "line too long";
1917             break;
1918         }
1919         for( p = line; isspace(*(byte*)p); p++ )
1920             ;
1921         if( !*p || *p == '#' )
1922             continue;
1923         keyword = p;
1924         if( *keyword == '%' ) {
1925             for( ; !isspace(*(byte*)p); p++ )
1926                 ;
1927             if( *p )
1928                 *p++ = 0;
1929             for( ; isspace(*(byte*)p); p++ )
1930                 ;
1931             value = p;
1932             trim_trailing_ws( value, strlen(value) );
1933             if( !ascii_strcasecmp( keyword, "%echo" ) )
1934                 log_info("%s\n", value );
1935             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
1936                 outctrl.dryrun = 1;
1937             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
1938                 outctrl.lnr = lnr;
1939                 proc_parameter_file( para, fname, &outctrl );
1940                 release_parameter_list( para );
1941                 para = NULL;
1942             }
1943             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
1944                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
1945                     ; /* still the same file - ignore it */
1946                 else {
1947                     m_free( outctrl.pub.newfname );
1948                     outctrl.pub.newfname = m_strdup( value );
1949                     outctrl.use_files = 1;
1950                 }
1951             }
1952             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
1953                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
1954                     ; /* still the same file - ignore it */
1955                 else {
1956                    m_free( outctrl.sec.newfname );
1957                    outctrl.sec.newfname = m_strdup( value );
1958                    outctrl.use_files = 1;
1959                 }
1960             }
1961             else
1962                 log_info("skipping control `%s' (%s)\n", keyword, value );
1963
1964
1965             continue;
1966         }
1967
1968
1969         if( !(p = strchr( p, ':' )) || p == keyword ) {
1970             err = "missing colon";
1971             break;
1972         }
1973         if( *p )
1974             *p++ = 0;
1975         for( ; isspace(*(byte*)p); p++ )
1976             ;
1977         if( !*p ) {
1978             err = "missing argument";
1979             break;
1980         }
1981         value = p;
1982         trim_trailing_ws( value, strlen(value) );
1983
1984         for(i=0; keywords[i].name; i++ ) {
1985             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
1986                 break;
1987         }
1988         if( !keywords[i].name ) {
1989             err = "unknown keyword";
1990             break;
1991         }
1992         if( keywords[i].key != pKEYTYPE && !para ) {
1993             err = "parameter block does not start with \"Key-Type\"";
1994             break;
1995         }
1996
1997         if( keywords[i].key == pKEYTYPE && para ) {
1998             outctrl.lnr = lnr;
1999             proc_parameter_file( para, fname, &outctrl );
2000             release_parameter_list( para );
2001             para = NULL;
2002         }
2003         else {
2004             for( r = para; r; r = r->next ) {
2005                 if( r->key == keywords[i].key )
2006                     break;
2007             }
2008             if( r ) {
2009                 err = "duplicate keyword";
2010                 break;
2011             }
2012         }
2013         r = m_alloc_clear( sizeof *r + strlen( value ) );
2014         r->lnr = lnr;
2015         r->key = keywords[i].key;
2016         strcpy( r->u.value, value );
2017         r->next = para;
2018         para = r;
2019     }
2020     if( err )
2021         log_error("%s:%d: %s\n", fname, lnr, err );
2022     else if( ferror(fp) ) {
2023         log_error("%s:%d: read error: %s\n", fname, lnr, strerror(errno) );
2024     }
2025     else if( para ) {
2026         outctrl.lnr = lnr;
2027         proc_parameter_file( para, fname, &outctrl );
2028     }
2029
2030     if( outctrl.use_files ) { /* close open streams */
2031         iobuf_close( outctrl.pub.stream );
2032         iobuf_close( outctrl.sec.stream );
2033         m_free( outctrl.pub.fname );
2034         m_free( outctrl.pub.newfname );
2035         m_free( outctrl.sec.fname );
2036         m_free( outctrl.sec.newfname );
2037     }
2038
2039     release_parameter_list( para );
2040     if( strcmp( fname, "-" ) )
2041         fclose(fp);
2042 }
2043
2044
2045 /****************
2046  * Generate a keypair
2047  * (fname is only used in batch mode)
2048  */
2049 void
2050 generate_keypair( const char *fname )
2051 {
2052     unsigned int nbits;
2053     char *uid = NULL;
2054     DEK *dek;
2055     STRING2KEY *s2k;
2056     int algo;
2057     unsigned int use;
2058     int both = 0;
2059     u32 expire;
2060     struct para_data_s *para = NULL;
2061     struct para_data_s *r;
2062     struct output_control_s outctrl;
2063
2064     memset( &outctrl, 0, sizeof( outctrl ) );
2065
2066     if( opt.batch ) {
2067         read_parameter_file( fname );
2068         return;
2069     }
2070
2071     algo = ask_algo( 0, &use );
2072     if( !algo ) { /* default: DSA with ElG subkey of the specified size */
2073         both = 1;
2074         r = m_alloc_clear( sizeof *r + 20 );
2075         r->key = pKEYTYPE;
2076         sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2077         r->next = para;
2078         para = r;
2079         tty_printf(_("DSA keypair will have 1024 bits.\n"));
2080         r = m_alloc_clear( sizeof *r + 20 );
2081         r->key = pKEYLENGTH;
2082         strcpy( r->u.value, "1024" );
2083         r->next = para;
2084         para = r;
2085
2086         algo = PUBKEY_ALGO_ELGAMAL_E;
2087         r = m_alloc_clear( sizeof *r + 20 );
2088         r->key = pSUBKEYTYPE;
2089         sprintf( r->u.value, "%d", algo );
2090         r->next = para;
2091         para = r;
2092     }
2093     else {
2094         r = m_alloc_clear( sizeof *r + 20 );
2095         r->key = pKEYTYPE;
2096         sprintf( r->u.value, "%d", algo );
2097         r->next = para;
2098         para = r;
2099
2100         if (use) {
2101             r = m_alloc_clear( sizeof *r + 20 );
2102             r->key = pKEYUSAGE;
2103             sprintf( r->u.value, "%s%s",
2104                      (use & PUBKEY_USAGE_SIG)? "sign ":"",
2105                      (use & PUBKEY_USAGE_ENC)? "encrypt ":"" );
2106             r->next = para;
2107             para = r;
2108         }
2109
2110     }
2111
2112     nbits = ask_keysize( algo );
2113     r = m_alloc_clear( sizeof *r + 20 );
2114     r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2115     sprintf( r->u.value, "%u", nbits);
2116     r->next = para;
2117     para = r;
2118
2119     expire = ask_expire_interval(0);
2120     r = m_alloc_clear( sizeof *r + 20 );
2121     r->key = pKEYEXPIRE;
2122     r->u.expire = expire;
2123     r->next = para;
2124     para = r;
2125     r = m_alloc_clear( sizeof *r + 20 );
2126     r->key = pSUBKEYEXPIRE;
2127     r->u.expire = expire;
2128     r->next = para;
2129     para = r;
2130
2131     uid = ask_user_id(0);
2132     if( !uid ) {
2133         log_error(_("Key generation canceled.\n"));
2134         release_parameter_list( para );
2135         return;
2136     }
2137     r = m_alloc_clear( sizeof *r + strlen(uid) );
2138     r->key = pUSERID;
2139     strcpy( r->u.value, uid );
2140     r->next = para;
2141     para = r;
2142
2143     dek = ask_passphrase( &s2k );
2144     if( dek ) {
2145         r = m_alloc_clear( sizeof *r );
2146         r->key = pPASSPHRASE_DEK;
2147         r->u.dek = dek;
2148         r->next = para;
2149         para = r;
2150         r = m_alloc_clear( sizeof *r );
2151         r->key = pPASSPHRASE_S2K;
2152         r->u.s2k = s2k;
2153         r->next = para;
2154         para = r;
2155     }
2156
2157     proc_parameter_file( para, "[internal]", &outctrl );
2158     release_parameter_list( para );
2159 }
2160
2161
2162 static void
2163 print_status_key_created (int letter, PKT_public_key *pk)
2164 {
2165   byte array[MAX_FINGERPRINT_LEN], *s;
2166   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
2167   size_t i, n;
2168   
2169   p = buf;
2170   *p++ = letter;
2171   *p++ = ' ';
2172   fingerprint_from_pk (pk, array, &n);
2173   s = array;
2174   for (i=0; i < n ; i++, s++, p += 2)
2175     sprintf (p, "%02X", *s);
2176   *p = 0;
2177   write_status_text (STATUS_KEY_CREATED, buf);
2178 }
2179
2180 static void
2181 do_generate_keypair( struct para_data_s *para,
2182                      struct output_control_s *outctrl )
2183 {
2184     KBNODE pub_root = NULL;
2185     KBNODE sec_root = NULL;
2186     PKT_secret_key *sk = NULL;
2187     const char *s;
2188     struct revocation_key *revkey;
2189     int rc;
2190     int did_sub = 0;
2191
2192     if( outctrl->dryrun ) {
2193         log_info("dry-run mode - key generation skipped\n");
2194         return;
2195     }
2196
2197
2198     if( outctrl->use_files ) {
2199         if( outctrl->pub.newfname ) {
2200             iobuf_close(outctrl->pub.stream);
2201             outctrl->pub.stream = NULL;
2202             m_free( outctrl->pub.fname );
2203             outctrl->pub.fname =  outctrl->pub.newfname;
2204             outctrl->pub.newfname = NULL;
2205
2206             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
2207             if( !outctrl->pub.stream ) {
2208                 log_error("can't create `%s': %s\n", outctrl->pub.newfname,
2209                                                      strerror(errno) );
2210                 return;
2211             }
2212             if( opt.armor ) {
2213                 outctrl->pub.afx.what = 1;
2214                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
2215                                                     &outctrl->pub.afx );
2216             }
2217         }
2218         if( outctrl->sec.newfname ) {
2219             iobuf_close(outctrl->sec.stream);
2220             outctrl->sec.stream = NULL;
2221             m_free( outctrl->sec.fname );
2222             outctrl->sec.fname =  outctrl->sec.newfname;
2223             outctrl->sec.newfname = NULL;
2224
2225             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
2226             if( !outctrl->sec.stream ) {
2227                 log_error("can't create `%s': %s\n", outctrl->sec.newfname,
2228                                                      strerror(errno) );
2229                 return;
2230             }
2231             if( opt.armor ) {
2232                 outctrl->sec.afx.what = 5;
2233                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
2234                                                     &outctrl->sec.afx );
2235             }
2236         }
2237         assert( outctrl->pub.stream );
2238         assert( outctrl->sec.stream );
2239         if( opt.verbose ) {
2240             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
2241             log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
2242         }
2243     }
2244
2245
2246     /* we create the packets as a tree of kbnodes. Because the structure
2247      * we create is known in advance we simply generate a linked list
2248      * The first packet is a dummy comment packet which we flag
2249      * as deleted.  The very first packet must always be a KEY packet.
2250      */
2251     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
2252     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
2253
2254     rc = do_create( get_parameter_algo( para, pKEYTYPE ),
2255                     get_parameter_uint( para, pKEYLENGTH ),
2256                     pub_root, sec_root,
2257                     get_parameter_dek( para, pPASSPHRASE_DEK ),
2258                     get_parameter_s2k( para, pPASSPHRASE_S2K ),
2259                     &sk,
2260                     get_parameter_u32( para, pKEYEXPIRE ) );
2261
2262     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
2263       {
2264         rc=write_direct_sig(pub_root,pub_root,sk,revkey);
2265         if(!rc)
2266           write_direct_sig(sec_root,pub_root,sk,revkey);
2267       }
2268
2269     if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
2270         write_uid(pub_root, s );
2271         if( !rc )
2272             write_uid(sec_root, s );
2273         if( !rc )
2274             rc = write_selfsig(pub_root, pub_root, sk,
2275                                get_parameter_uint (para, pKEYUSAGE));
2276         if( !rc )
2277             rc = write_selfsig(sec_root, pub_root, sk,
2278                                get_parameter_uint (para, pKEYUSAGE));
2279     }
2280
2281     if( get_parameter( para, pSUBKEYTYPE ) ) {
2282         rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
2283                         get_parameter_uint( para, pSUBKEYLENGTH ),
2284                         pub_root, sec_root,
2285                         get_parameter_dek( para, pPASSPHRASE_DEK ),
2286                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
2287                         NULL,
2288                         get_parameter_u32( para, pSUBKEYEXPIRE ) );
2289         if( !rc )
2290             rc = write_keybinding(pub_root, pub_root, sk,
2291                                   get_parameter_uint (para, pSUBKEYUSAGE));
2292         if( !rc )
2293             rc = write_keybinding(sec_root, pub_root, sk,
2294                                   get_parameter_uint (para, pSUBKEYUSAGE));
2295         did_sub = 1;
2296     }
2297
2298
2299     if( !rc && outctrl->use_files ) { /* direct write to specified files */
2300         rc = write_keyblock( outctrl->pub.stream, pub_root );
2301         if( rc )
2302             log_error("can't write public key: %s\n", g10_errstr(rc) );
2303         if( !rc ) {
2304             rc = write_keyblock( outctrl->sec.stream, sec_root );
2305             if( rc )
2306                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
2307         }
2308
2309     }
2310     else if( !rc ) { /* write to the standard keyrings */
2311         KEYDB_HANDLE pub_hd = keydb_new (0);
2312         KEYDB_HANDLE sec_hd = keydb_new (1);
2313
2314         /* FIXME: we may have to create the keyring first */
2315         rc = keydb_locate_writable (pub_hd, NULL);
2316         if (rc) 
2317             log_error (_("no writable public keyring found: %s\n"),
2318                        g10_errstr (rc));
2319
2320         if (!rc) {  
2321             rc = keydb_locate_writable (sec_hd, NULL);
2322             if (rc) 
2323                 log_error (_("no writable secret keyring found: %s\n"),
2324                            g10_errstr (rc));
2325         }
2326
2327         if (!rc && opt.verbose) {
2328             log_info(_("writing public key to `%s'\n"),
2329                      keydb_get_resource_name (pub_hd));
2330             log_info(_("writing secret key to `%s'\n"),
2331                      keydb_get_resource_name (sec_hd));
2332         }
2333
2334         if (!rc) {
2335             rc = keydb_insert_keyblock (pub_hd, pub_root);
2336             if (rc)
2337                 log_error (_("error writing public keyring `%s': %s\n"),
2338                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2339         }
2340
2341         if (!rc) {
2342             rc = keydb_insert_keyblock (sec_hd, sec_root);
2343             if (rc)
2344                 log_error (_("error writing secret keyring `%s': %s\n"),
2345                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2346         }
2347
2348         keydb_release (pub_hd);
2349         keydb_release (sec_hd);
2350
2351         if (!rc) {
2352             int no_enc_rsa =
2353                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
2354                 && get_parameter_uint( para, pKEYUSAGE )
2355                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
2356             PKT_public_key *pk = find_kbnode (pub_root, 
2357                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2358             
2359             update_ownertrust (pk,
2360                                ((get_ownertrust (pk) & ~TRUST_MASK)
2361                                 | TRUST_ULTIMATE ));
2362
2363             if (!opt.batch) {
2364                 tty_printf(_("public and secret key created and signed.\n") );
2365                 tty_printf(_("key marked as ultimately trusted.\n") );
2366                 tty_printf("\n");
2367                 list_keyblock(pub_root,0,1,NULL);
2368             }
2369             
2370
2371             if( !opt.batch
2372                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
2373                      || no_enc_rsa )
2374                 && !get_parameter( para, pSUBKEYTYPE ) )
2375             {
2376                 tty_printf(_("Note that this key cannot be used for "
2377                              "encryption.  You may want to use\n"
2378                              "the command \"--edit-key\" to generate a "
2379                              "secondary key for this purpose.\n") );
2380             }
2381         }
2382     }
2383
2384     if( rc ) {
2385         if( opt.batch )
2386             log_error("key generation failed: %s\n", g10_errstr(rc) );
2387         else
2388             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
2389     }
2390     else {
2391         PKT_public_key *pk = find_kbnode (pub_root, 
2392                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2393         print_status_key_created (did_sub? 'B':'P', pk);
2394     }
2395     release_kbnode( pub_root );
2396     release_kbnode( sec_root );
2397     if( sk ) /* the unprotected  secret key */
2398         free_secret_key(sk);
2399 }
2400
2401
2402 /****************
2403  * add a new subkey to an existing key.
2404  * Returns true if a new key has been generated and put into the keyblocks.
2405  */
2406 int
2407 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
2408 {
2409     int okay=0, rc=0;
2410     KBNODE node;
2411     PKT_secret_key *sk = NULL; /* this is the primary sk */
2412     int algo;
2413     unsigned int use;
2414     u32 expire;
2415     unsigned nbits;
2416     char *passphrase = NULL;
2417     DEK *dek = NULL;
2418     STRING2KEY *s2k = NULL;
2419     u32 cur_time;
2420
2421     /* break out the primary secret key */
2422     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
2423     if( !node ) {
2424         log_error("Oops; secret key not found anymore!\n");
2425         goto leave;
2426     }
2427
2428     /* make a copy of the sk to keep the protected one in the keyblock */
2429     sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
2430
2431     cur_time = make_timestamp();
2432     if( sk->timestamp > cur_time ) {
2433         ulong d = sk->timestamp - cur_time;
2434         log_info( d==1 ? _("key has been created %lu second "
2435                            "in future (time warp or clock problem)\n")
2436                        : _("key has been created %lu seconds "
2437                            "in future (time warp or clock problem)\n"), d );
2438         if( !opt.ignore_time_conflict ) {
2439             rc = G10ERR_TIME_CONFLICT;
2440             goto leave;
2441         }
2442     }
2443
2444     if (sk->version < 4) {
2445         log_info (_("NOTE: creating subkeys for v3 keys "
2446                     "is not OpenPGP compliant\n"));
2447         goto leave;
2448     }
2449
2450     /* unprotect to get the passphrase */
2451     switch( is_secret_key_protected( sk ) ) {
2452       case -1:
2453         rc = G10ERR_PUBKEY_ALGO;
2454         break;
2455       case 0:
2456         tty_printf("This key is not protected.\n");
2457         break;
2458       default:
2459         tty_printf("Key is protected.\n");
2460         rc = check_secret_key( sk, 0 );
2461         if( !rc )
2462             passphrase = get_last_passphrase();
2463         break;
2464     }
2465     if( rc )
2466         goto leave;
2467
2468
2469     algo = ask_algo( 1, &use );
2470     assert(algo);
2471     nbits = ask_keysize( algo );
2472     expire = ask_expire_interval(0);
2473     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
2474                                                   _("Really create? ") ) )
2475         goto leave;
2476
2477     if( passphrase ) {
2478         s2k = m_alloc_secure( sizeof *s2k );
2479         s2k->mode = opt.s2k_mode;
2480         s2k->hash_algo = opt.s2k_digest_algo;
2481         set_next_passphrase( passphrase );
2482         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2483                                  NULL, NULL );
2484     }
2485
2486     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
2487                                       dek, s2k, NULL, expire );
2488     if( !rc )
2489         rc = write_keybinding(pub_keyblock, pub_keyblock, sk, use);
2490     if( !rc )
2491         rc = write_keybinding(sec_keyblock, pub_keyblock, sk, use);
2492     if( !rc ) {
2493         okay = 1;
2494         write_status_text (STATUS_KEY_CREATED, "S");
2495     }
2496
2497   leave:
2498     if( rc )
2499         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
2500     m_free( passphrase );
2501     m_free( dek );
2502     m_free( s2k );
2503     if( sk ) /* release the copy of the (now unprotected) secret key */
2504         free_secret_key(sk);
2505     set_next_passphrase( NULL );
2506     return okay;
2507 }
2508
2509 /****************
2510  * Write a keyblock to an output stream
2511  */
2512 static int
2513 write_keyblock( IOBUF out, KBNODE node )
2514 {
2515     for( ; node ; node = node->next ) {
2516         int rc = build_packet( out, node->pkt );
2517         if( rc ) {
2518             log_error("build_packet(%d) failed: %s\n",
2519                         node->pkt->pkttype, g10_errstr(rc) );
2520             return G10ERR_WRITE_FILE;
2521         }
2522     }
2523     return 0;
2524 }