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