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