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