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