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