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