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