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