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