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