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