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