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