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