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