* gpgsm.c (main): Add secmem features and set the random seed file.
[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 key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
744                const char *topname, const char *elems)
745 {
746   gcry_sexp_t list, l2;
747   const char *s;
748   int i, idx;
749   int rc = 0;
750
751   list = gcry_sexp_find_token (sexp, topname, 0);
752   if (!list)
753     return gpg_error (GPG_ERR_INV_OBJ);
754   l2 = gcry_sexp_cadr (list);
755   gcry_sexp_release (list);
756   list = l2;
757   if (!list)
758     return gpg_error (GPG_ERR_NO_OBJ);
759
760   for (idx=0,s=elems; *s; s++, idx++)
761     {
762       l2 = gcry_sexp_find_token (list, s, 1);
763       if (!l2)
764         {
765           rc = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
766           goto leave;
767         }
768       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
769       gcry_sexp_release (l2);
770       if (!array[idx]) 
771         {
772           rc = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
773           goto leave;
774         }
775     }
776   gcry_sexp_release (list);
777
778  leave:
779   if (rc)
780     {
781       for (i=0; i<idx; i++)
782         {
783           xfree (array[i]);
784           array[i] = NULL;
785         }
786       gcry_sexp_release (list);
787     }
788   return rc;
789 }
790
791
792 static int
793 genhelp_protect (DEK *dek, STRING2KEY *s2k, PKT_secret_key *sk)
794 {
795   int rc = 0;
796
797   if (dek)
798     {
799       sk->protect.algo = dek->algo;
800       sk->protect.s2k = *s2k;
801       rc = protect_secret_key (sk, dek);
802       if (rc)
803         log_error ("protect_secret_key failed: %s\n", gpg_strerror (rc) );
804     }
805
806   return rc;
807 }
808
809 static void
810 genhelp_factors (gcry_sexp_t misc_key_info, KBNODE sec_root)
811 {
812   size_t n;
813   char *buf;
814   
815   if (misc_key_info)
816     {
817       /* DSA: don't know whether it makes sense to have the factors, so for now
818          we store them in the secret keyring (but they are not secret)
819          p = 2 * q * f1 * f2 * ... * fn
820          We store only f1 to f_n-1;  fn can be calculated because p and q
821          are known. */
822       n = gcry_sexp_sprint (misc_key_info, 0, NULL, 0);
823       buf = xmalloc (n+4);
824       strcpy (buf, "#::");
825       n = gcry_sexp_sprint (misc_key_info, 0, buf+3, n);
826       if (n)
827         {
828           n += 3;
829           add_kbnode (sec_root, make_comment_node_from_buffer (buf, n));
830         }
831       xfree (buf);
832       gcry_sexp_release (misc_key_info);
833     }
834 }
835
836
837 static int
838 gen_elg(int algo, unsigned int nbits,
839         KBNODE pub_root, KBNODE sec_root, DEK *dek,
840         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
841 {
842   int rc;
843   PACKET *pkt;
844   PKT_secret_key *sk;
845   PKT_public_key *pk;
846   gcry_sexp_t s_parms, s_key;
847   gcry_sexp_t misc_key_info;
848   
849   assert (is_ELGAMAL(algo));
850
851   if (nbits < 512)
852     {
853       nbits = 1024;
854       log_info (_("keysize invalid; using %u bits\n"), nbits);
855     }
856
857   if ((nbits % 32))
858     {
859       nbits = ((nbits + 31) / 32) * 32;
860       log_info (_("keysize rounded up to %u bits\n"), nbits);
861     }
862
863   rc = gcry_sexp_build ( &s_parms, NULL,
864                          "(genkey(%s(nbits %d)))",
865                          algo == GCRY_PK_ELG_E ? "openpgp-elg" :
866                          algo == GCRY_PK_ELG     ? "elg" : "x-oops" ,
867                          (int)nbits);
868   if (rc)
869     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
870   
871   rc = gcry_pk_genkey (&s_key, s_parms);
872   gcry_sexp_release (s_parms);
873   if (rc)
874     {
875       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
876       return rc;
877     }
878
879   sk = xcalloc (1, sizeof *sk);
880   pk = xcalloc (1, sizeof *pk);
881   sk->timestamp = pk->timestamp = make_timestamp();
882   sk->version = pk->version = 4;
883   if (expireval)
884     sk->expiredate = pk->expiredate = sk->timestamp + expireval;
885   sk->pubkey_algo = pk->pubkey_algo = algo;
886
887   rc = key_from_sexp (pk->pkey, s_key, "public-key", "pgy");
888   if (rc) 
889     {
890       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
891       gcry_sexp_release (s_key);
892       return rc;
893     }
894   rc = key_from_sexp (sk->skey, s_key, "private-key", "pgyx");
895   if (rc)
896     {
897       log_error("key_from_sexp failed: %s\n", gpg_strerror (rc) );
898       gcry_sexp_release (s_key);
899       return rc;
900     }
901   misc_key_info = gcry_sexp_find_token (s_key, "misc-key-info", 0);
902   gcry_sexp_release (s_key);
903
904   sk->is_protected = 0;
905   sk->protect.algo = 0;
906
907   sk->csum = checksum_mpi (sk->skey[3]);
908   if (ret_sk) /* not a subkey: return an unprotected version of the sk */
909     *ret_sk = copy_secret_key (NULL, sk);
910
911   rc = genhelp_protect (dek, s2k, sk);
912   if (rc)
913     {
914       free_public_key (pk);
915       free_secret_key (sk);
916       gcry_sexp_release (misc_key_info);
917       return rc;
918     }
919
920   pkt = xcalloc (1,sizeof *pkt);
921   pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
922   pkt->pkt.public_key = pk;
923   add_kbnode(pub_root, new_kbnode( pkt ));
924   
925   /* don't know whether it makes sense to have the factors, so for now
926    * we store them in the secret keyring (but they are not secret) */
927   pkt = xcalloc (1,sizeof *pkt);
928   pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
929   pkt->pkt.secret_key = sk;
930   add_kbnode(sec_root, new_kbnode( pkt ));
931   
932   genhelp_factors (misc_key_info, sec_root);
933   
934   return 0;
935 }
936
937
938 /****************
939  * Generate a DSA key
940  */
941 static int
942 gen_dsa (unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
943          STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
944 {
945   int rc;
946   PACKET *pkt;
947   PKT_secret_key *sk;
948   PKT_public_key *pk;
949   gcry_sexp_t s_parms, s_key;
950   gcry_sexp_t misc_key_info;
951
952   if (nbits > 1024 || nbits < 512)
953     {
954       nbits = 1024;
955       log_info(_("keysize invalid; using %u bits\n"), nbits);
956     }
957
958   if ((nbits % 64))
959     {
960       nbits = ((nbits + 63) / 64) * 64;
961       log_info (_("keysize rounded up to %u bits\n"), nbits);
962     }
963
964   rc = gcry_sexp_build (&s_parms, NULL,
965                         "(genkey(dsa(nbits %d)))",
966                         (int)nbits);
967   if (rc)
968     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
969   
970   rc = gcry_pk_genkey (&s_key, s_parms);
971   gcry_sexp_release (s_parms);
972   if (rc)
973     {
974       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
975       return rc;
976     }
977
978   sk = xcalloc (1, sizeof *sk );
979   pk = xcalloc (1, sizeof *pk );
980   sk->timestamp = pk->timestamp = make_timestamp();
981   sk->version = pk->version = 4;
982   if (expireval) 
983     sk->expiredate = pk->expiredate = sk->timestamp + expireval;
984   sk->pubkey_algo = pk->pubkey_algo = PUBKEY_ALGO_DSA;
985
986   rc = key_from_sexp (pk->pkey, s_key, "public-key", "pqgy");
987   if (rc) 
988     {
989       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc));
990       gcry_sexp_release (s_key);
991       return rc;
992     }
993   rc = key_from_sexp (sk->skey, s_key, "private-key", "pqgyx");
994   if (rc) 
995     {
996       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
997       gcry_sexp_release (s_key);
998       return rc;
999     }
1000   misc_key_info = gcry_sexp_find_token (s_key, "misc-key-info", 0);
1001   gcry_sexp_release (s_key);
1002
1003   sk->is_protected = 0;
1004   sk->protect.algo = 0;
1005
1006   sk->csum = checksum_mpi ( sk->skey[4] );
1007   if (ret_sk) /* not a subkey: return an unprotected version of the sk */
1008     *ret_sk = copy_secret_key( NULL, sk );
1009
1010   rc = genhelp_protect (dek, s2k, sk);
1011   if (rc)
1012     {
1013       free_public_key (pk);
1014       free_secret_key (sk);
1015       gcry_sexp_release (misc_key_info);
1016       return rc;
1017     }
1018
1019   pkt = xcalloc (1,sizeof *pkt);
1020   pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
1021   pkt->pkt.public_key = pk;
1022   add_kbnode(pub_root, new_kbnode( pkt ));
1023
1024   pkt = xcalloc (1,sizeof *pkt);
1025   pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
1026   pkt->pkt.secret_key = sk;
1027   add_kbnode(sec_root, new_kbnode( pkt ));
1028
1029   genhelp_factors (misc_key_info, sec_root);
1030
1031   return 0;
1032 }
1033
1034
1035 /* 
1036  * Generate an RSA key.
1037  */
1038 static int
1039 gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
1040         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
1041 {
1042   int rc;
1043   PACKET *pkt;
1044   PKT_secret_key *sk;
1045   PKT_public_key *pk;
1046   gcry_sexp_t s_parms, s_key;
1047
1048   assert (is_RSA(algo));
1049
1050   if (nbits < 1024)
1051     {
1052       nbits = 1024;
1053       log_info(_("keysize invalid; using %u bits\n"), nbits);
1054     }
1055
1056   if ((nbits % 32))
1057     {
1058       nbits = ((nbits + 31) / 32) * 32;
1059       log_info (_("keysize rounded up to %u bits\n"), nbits);
1060     }
1061
1062   rc = gcry_sexp_build (&s_parms, NULL,
1063                         "(genkey(rsa(nbits %d)))",
1064                         (int)nbits);
1065   if (rc)
1066     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
1067   
1068   rc = gcry_pk_genkey (&s_key, s_parms);
1069   gcry_sexp_release (s_parms);
1070   if (rc)
1071     {
1072       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
1073       return rc;
1074     }
1075
1076   sk = xcalloc (1, sizeof *sk );
1077   pk = xcalloc (1, sizeof *pk );
1078   sk->timestamp = pk->timestamp = make_timestamp();
1079   sk->version = pk->version = 4;
1080   if (expireval) 
1081     sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1082   sk->pubkey_algo = pk->pubkey_algo = algo;
1083
1084   rc = key_from_sexp (pk->pkey, s_key, "public-key", "ne");
1085   if (rc) 
1086     {
1087       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc));
1088       gcry_sexp_release (s_key);
1089       return rc;
1090     }
1091   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
1092   if (rc) 
1093     {
1094       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1095       gcry_sexp_release (s_key);
1096       return rc;
1097     }
1098   gcry_sexp_release (s_key);
1099
1100   sk->is_protected = 0;
1101   sk->protect.algo = 0;
1102
1103   sk->csum  = checksum_mpi (sk->skey[2] );
1104   sk->csum += checksum_mpi (sk->skey[3] );
1105   sk->csum += checksum_mpi (sk->skey[4] );
1106   sk->csum += checksum_mpi (sk->skey[5] );
1107   if (ret_sk) /* not a subkey: return an unprotected version of the sk */
1108     *ret_sk = copy_secret_key (NULL, sk);
1109
1110   rc = genhelp_protect (dek, s2k, sk);
1111   if (rc)
1112     {
1113       free_public_key (pk);
1114       free_secret_key (sk);
1115       return rc;
1116     }
1117
1118   pkt = xcalloc (1,sizeof *pkt);
1119   pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
1120   pkt->pkt.public_key = pk;
1121   add_kbnode (pub_root, new_kbnode( pkt ));
1122
1123   pkt = xcalloc (1,sizeof *pkt);
1124   pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
1125   pkt->pkt.secret_key = sk;
1126   add_kbnode(sec_root, new_kbnode( pkt ));
1127
1128   return 0;
1129 }
1130
1131
1132 /****************
1133  * check valid days:
1134  * return 0 on error or the multiplier
1135  */
1136 static int
1137 check_valid_days( const char *s )
1138 {
1139     if( !isdigit(*s) )
1140         return 0;
1141     for( s++; *s; s++)
1142         if( !isdigit(*s) )
1143             break;
1144     if( !*s )
1145         return 1;
1146     if( s[1] )
1147         return 0; /* e.g. "2323wc" */
1148     if( *s == 'd' || *s == 'D' )
1149         return 1;
1150     if( *s == 'w' || *s == 'W' )
1151         return 7;
1152     if( *s == 'm' || *s == 'M' )
1153         return 30;
1154     if( *s == 'y' || *s == 'Y' )
1155         return 365;
1156     return 0;
1157 }
1158
1159
1160 /****************
1161  * Returns: 0 to create both a DSA and a ElGamal key.
1162  *          and only if key flags are to be written the desired usage.
1163  */
1164 static int
1165 ask_algo (int addmode, unsigned int *r_usage)
1166 {
1167     char *answer;
1168     int algo;
1169
1170     *r_usage = 0;
1171     tty_printf(_("Please select what kind of key you want:\n"));
1172     if( !addmode )
1173         tty_printf(_("   (%d) DSA and ElGamal (default)\n"), 1 );
1174     tty_printf(    _("   (%d) DSA (sign only)\n"), 2 );
1175     if( addmode )
1176         tty_printf(    _("   (%d) ElGamal (encrypt only)\n"), 3 );
1177     if (opt.expert)
1178         tty_printf(    _("   (%d) ElGamal (sign and encrypt)\n"), 4 );
1179     tty_printf(    _("   (%d) RSA (sign only)\n"), 5 );
1180     if (addmode)
1181         tty_printf(    _("   (%d) RSA (encrypt only)\n"), 6 );
1182     if (opt.expert)
1183       tty_printf(    _("   (%d) RSA (sign and encrypt)\n"), 7 );
1184
1185     for(;;) {
1186         answer = cpr_get("keygen.algo",_("Your selection? "));
1187         cpr_kill_prompt();
1188         algo = *answer? atoi(answer): 1;
1189         xfree (answer);
1190         if( algo == 1 && !addmode ) {
1191             algo = 0;   /* create both keys */
1192             break;
1193         }
1194         else if( algo == 7 && opt.expert ) {
1195             algo = PUBKEY_ALGO_RSA;
1196             *r_usage = PUBKEY_USAGE_ENC | PUBKEY_USAGE_SIG;
1197             break;
1198         }
1199         else if( algo == 6 && addmode ) {
1200             algo = PUBKEY_ALGO_RSA;
1201             *r_usage = PUBKEY_USAGE_ENC;
1202             break;
1203         }
1204         else if( algo == 5 ) {
1205             algo = PUBKEY_ALGO_RSA;
1206             *r_usage = PUBKEY_USAGE_SIG;
1207             break;
1208         }
1209         else if( algo == 4 && opt.expert)
1210           {
1211             tty_printf(_(
1212 "The use of this algorithm is only supported by GnuPG.  You will not be\n"
1213 "able to use this key to communicate with PGP users.  This algorithm is also\n"
1214 "very slow, and may not be as secure as the other choices.\n"));
1215
1216             if( cpr_get_answer_is_yes("keygen.algo.elg_se",
1217                                       _("Create anyway? ")))
1218               {
1219                 algo = PUBKEY_ALGO_ELGAMAL;
1220                 break;
1221               }
1222         }
1223         else if( algo == 3 && addmode ) {
1224             algo = PUBKEY_ALGO_ELGAMAL_E;
1225             break;
1226         }
1227         else if( algo == 2 ) {
1228             algo = PUBKEY_ALGO_DSA;
1229             break;
1230         }
1231         else
1232             tty_printf(_("Invalid selection.\n"));
1233     }
1234     return algo;
1235 }
1236
1237
1238 static unsigned
1239 ask_keysize( int algo )
1240 {
1241     char *answer;
1242     unsigned nbits;
1243
1244     if (algo != PUBKEY_ALGO_DSA && algo != PUBKEY_ALGO_RSA) {
1245         tty_printf (_("About to generate a new %s keypair.\n"
1246                       "              minimum keysize is  768 bits\n"
1247                       "              default keysize is 1024 bits\n"
1248                       "    highest suggested keysize is 2048 bits\n"),
1249                     gcry_pk_algo_name (algo) );
1250     }
1251
1252     for(;;) {
1253         answer = cpr_get("keygen.size",
1254                           _("What keysize do you want? (1024) "));
1255         cpr_kill_prompt();
1256         nbits = *answer? atoi(answer): 1024;
1257         xfree (answer);
1258         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
1259             tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
1260         else if( algo == PUBKEY_ALGO_RSA && nbits < 1024 )
1261             tty_printf(_("keysize too small;"
1262                          " 1024 is smallest value allowed for RSA.\n"));
1263         else if( nbits < 768 )
1264             tty_printf(_("keysize too small;"
1265                          " 768 is smallest value allowed.\n"));
1266         else if( nbits > 4096 ) {
1267             /* It is ridiculous and an annoyance to use larger key sizes!
1268              * GnuPG can handle much larger sizes; but it takes an eternity
1269              * to create such a key (but less than the time the Sirius
1270              * Computer Corporation needs to process one of the usual
1271              * complaints) and {de,en}cryption although needs some time.
1272              * So, before you complain about this limitation, I suggest that
1273              * you start a discussion with Marvin about this theme and then
1274              * do whatever you want. */
1275             tty_printf(_("keysize too large; %d is largest value allowed.\n"),
1276                                                                          4096);
1277         }
1278         else if( nbits > 2048 && !cpr_enabled() ) {
1279             tty_printf(
1280                 _("Keysizes larger than 2048 are not suggested because\n"
1281                   "computations take REALLY long!\n"));
1282             if( cpr_get_answer_is_yes("keygen.size.huge.okay",_(
1283                         "Are you sure that you want this keysize? ")) ) {
1284                 tty_printf(_("Okay, but keep in mind that your monitor "
1285                              "and keyboard radiation is also very vulnerable "
1286                              "to attacks!\n"));
1287                 break;
1288             }
1289         }
1290         else
1291             break;
1292     }
1293     tty_printf(_("Requested keysize is %u bits\n"), nbits );
1294     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
1295         nbits = ((nbits + 63) / 64) * 64;
1296         tty_printf(_("rounded up to %u bits\n"), nbits );
1297     }
1298     else if( (nbits % 32) ) {
1299         nbits = ((nbits + 31) / 32) * 32;
1300         tty_printf(_("rounded up to %u bits\n"), nbits );
1301     }
1302     return nbits;
1303 }
1304
1305
1306 /****************
1307  * Parse an expire string and return it's value in days.
1308  * Returns -1 on error.
1309  */
1310 static int
1311 parse_expire_string( const char *string )
1312 {
1313     int mult;
1314     u32 abs_date=0;
1315     u32 curtime = make_timestamp();
1316     int valid_days;
1317
1318     if( !*string )
1319         valid_days = 0;
1320     else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime ) {
1321         /* This calculation is not perfectly okay because we
1322          * are later going to simply multiply by 86400 and don't
1323          * correct for leapseconds.  A solution would be to change
1324          * the whole implemenation to work with dates and not intervals
1325          * which are required for v3 keys.
1326          */
1327         valid_days = abs_date/86400-curtime/86400+1;
1328     }
1329     else if( (mult=check_valid_days(string)) ) {
1330         valid_days = atoi(string) * mult;
1331         if( valid_days < 0 || valid_days > 39447 )
1332             valid_days = 0;
1333     }
1334     else {
1335         valid_days = -1;
1336     }
1337     return valid_days;
1338 }
1339
1340 /* object == 0 for a key, and 1 for a sig */
1341 u32
1342 ask_expire_interval(int object)
1343 {
1344     char *answer;
1345     int valid_days=0;
1346     u32 interval = 0;
1347
1348     switch(object)
1349       {
1350       case 0:
1351         tty_printf(_("Please specify how long the key should be valid.\n"
1352                      "         0 = key does not expire\n"
1353                      "      <n>  = key expires in n days\n"
1354                      "      <n>w = key expires in n weeks\n"
1355                      "      <n>m = key expires in n months\n"
1356                      "      <n>y = key expires in n years\n"));
1357         break;
1358
1359       case 1:
1360         tty_printf(_("Please specify how long the signature should be valid.\n"
1361                      "         0 = signature does not expire\n"
1362                      "      <n>  = signature expires in n days\n"
1363                      "      <n>w = signature expires in n weeks\n"
1364                      "      <n>m = signature expires in n months\n"
1365                      "      <n>y = signature expires in n years\n"));
1366         break;
1367
1368       default:
1369         BUG();
1370       }
1371
1372     /* Note: The elgamal subkey for DSA has no expiration date because
1373      * it must be signed with the DSA key and this one has the expiration
1374      * date */
1375
1376     answer = NULL;
1377     for(;;) {
1378         u32 curtime=make_timestamp();
1379
1380         xfree (answer);
1381         if(object==0)
1382           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1383         else
1384           answer = cpr_get("siggen.valid",_("Signature is valid for? (0) "));
1385         cpr_kill_prompt();
1386         trim_spaces(answer);
1387         valid_days = parse_expire_string( answer );
1388         if( valid_days < 0 ) {
1389             tty_printf(_("invalid value\n"));
1390             continue;
1391         }
1392
1393         if( !valid_days ) {
1394             tty_printf(_("%s does not expire at all\n"),
1395                        object==0?"Key":"Signature");
1396             interval = 0;
1397         }
1398         else {
1399             interval = valid_days * 86400L;
1400             /* print the date when the key expires */
1401             tty_printf(_("%s expires at %s\n"),
1402                         object==0?"Key":"Signature",
1403                         asctimestamp((ulong)(curtime + interval) ) );
1404             /* FIXME: This check yields warning some machines: write a
1405                configure check and do this check here only for 32 bit
1406                machines */
1407             if( (time_t)((ulong)(curtime+interval)) < 0 )
1408                 tty_printf(_("Your system can't display dates beyond 2038.\n"
1409                     "However, it will be correctly handled up to 2106.\n"));
1410         }
1411
1412         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1413                                             _("Is this correct (y/n)? ")) )
1414             break;
1415     }
1416     xfree (answer);
1417     return interval;
1418 }
1419
1420 u32
1421 ask_expiredate()
1422 {
1423     u32 x = ask_expire_interval(0);
1424     return x? make_timestamp() + x : 0;
1425 }
1426
1427
1428 static int
1429 count_chr( const char *string, int c )
1430 {
1431   int count;
1432
1433   for (count=0; *string; string++ )
1434     if ( *string == c )
1435       count++;
1436   return count;
1437 }
1438
1439
1440 static int
1441 has_invalid_email_chars( const char *s )
1442 {
1443     int at_seen=0;
1444     static char valid_chars[] = "01234567890_-."
1445                                 "abcdefghijklmnopqrstuvwxyz"
1446                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1447
1448     for( ; *s; s++ ) {
1449         if( *s & 0x80 )
1450             return 1;
1451         if( *s == '@' )
1452             at_seen=1;
1453         else if( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1454             return 1;
1455         else if( at_seen && !strchr( valid_chars, *s ) )
1456             return 1;
1457     }
1458     return 0;
1459 }
1460
1461
1462 static char *
1463 ask_user_id( int mode )
1464 {
1465     char *answer;
1466     char *aname, *acomment, *amail, *uid;
1467
1468     if( !mode )
1469         tty_printf( _("\n"
1470 "You need a User-ID to identify your key; the software constructs the user id\n"
1471 "from Real Name, Comment and Email Address in this form:\n"
1472 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
1473     uid = aname = acomment = amail = NULL;
1474     for(;;) {
1475         char *p;
1476         int fail=0;
1477
1478         if( !aname ) {
1479             for(;;) {
1480                 xfree (aname);
1481                 aname = cpr_get("keygen.name",_("Real name: "));
1482                 trim_spaces(aname);
1483                 cpr_kill_prompt();
1484
1485                 if( opt.allow_freeform_uid )
1486                     break;
1487
1488                 if( strpbrk( aname, "<>" ) )
1489                     tty_printf(_("Invalid character in name\n"));
1490                 else if( isdigit(*aname) )
1491                     tty_printf(_("Name may not start with a digit\n"));
1492                 else if( strlen(aname) < 5 )
1493                     tty_printf(_("Name must be at least 5 characters long\n"));
1494                 else
1495                     break;
1496             }
1497         }
1498         if( !amail ) {
1499             for(;;) {
1500                 xfree (amail);
1501                 amail = cpr_get("keygen.email",_("Email address: "));
1502                 trim_spaces(amail);
1503                 cpr_kill_prompt();
1504                 if( !*amail )
1505                     break;   /* no email address is okay */
1506                 else if( has_invalid_email_chars(amail)
1507                          || count_chr(amail,'@') != 1
1508                          || *amail == '@'
1509                          || amail[strlen(amail)-1] == '@'
1510                          || amail[strlen(amail)-1] == '.'
1511                          || strstr(amail, "..") )
1512                     tty_printf(_("Not a valid email address\n"));
1513                 else
1514                     break;
1515             }
1516         }
1517         if( !acomment ) {
1518             for(;;) {
1519                 xfree (acomment);
1520                 acomment = cpr_get("keygen.comment",_("Comment: "));
1521                 trim_spaces(acomment);
1522                 cpr_kill_prompt();
1523                 if( !*acomment )
1524                     break;   /* no comment is okay */
1525                 else if( strpbrk( acomment, "()" ) )
1526                     tty_printf(_("Invalid character in comment\n"));
1527                 else
1528                     break;
1529             }
1530         }
1531
1532
1533         xfree (uid);
1534         uid = p = xmalloc (strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1535         p = stpcpy(p, aname );
1536         if( *acomment )
1537             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1538         if( *amail )
1539             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1540
1541         /* print a note in case that UTF8 mapping has to be done */
1542         for(p=uid; *p; p++ ) {
1543             if( *p & 0x80 ) {
1544                 tty_printf(_("You are using the `%s' character set.\n"),
1545                            get_native_charset() );
1546                 break;
1547             }
1548         }
1549
1550         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1551         /* fixme: add a warning if this user-id already exists */
1552         if( !*amail && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1553             fail = 1;
1554             tty_printf(_("Please don't put the email address "
1555                           "into the real name or the comment\n") );
1556         }
1557
1558         for(;;) {
1559             const char *ansstr = _("NnCcEeOoQq");
1560
1561             if( strlen(ansstr) != 10 )
1562                 BUG();
1563             if( cpr_enabled() ) {
1564                 answer = xstrdup (ansstr+6);
1565                 answer[1] = 0;
1566             }
1567             else {
1568                 answer = cpr_get("keygen.userid.cmd", fail?
1569                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1570                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1571                 cpr_kill_prompt();
1572             }
1573             if( strlen(answer) > 1 )
1574                 ;
1575             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1576                 xfree (aname); aname = NULL;
1577                 break;
1578             }
1579             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1580                 xfree (acomment); acomment = NULL;
1581                 break;
1582             }
1583             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1584                 xfree (amail); amail = NULL;
1585                 break;
1586             }
1587             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1588                 if( fail ) {
1589                     tty_printf(_("Please correct the error first\n"));
1590                 }
1591                 else {
1592                     xfree (aname); aname = NULL;
1593                     xfree (acomment); acomment = NULL;
1594                     xfree (amail); amail = NULL;
1595                     break;
1596                 }
1597             }
1598             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1599                 xfree (aname); aname = NULL;
1600                 xfree (acomment); acomment = NULL;
1601                 xfree (amail); amail = NULL;
1602                 xfree (uid); uid = NULL;
1603                 break;
1604             }
1605             xfree (answer);
1606         }
1607         xfree (answer);
1608         if( !amail && !acomment && !amail )
1609             break;
1610         xfree (uid); uid = NULL;
1611     }
1612     if( uid ) {
1613         char *p = native_to_utf8( uid );
1614         xfree ( uid );
1615         uid = p;
1616     }
1617     return uid;
1618 }
1619
1620
1621 static DEK *
1622 ask_passphrase( STRING2KEY **ret_s2k )
1623 {
1624     DEK *dek = NULL;
1625     STRING2KEY *s2k;
1626     const char *errtext = NULL;
1627
1628     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1629
1630     s2k = xmalloc_secure ( sizeof *s2k );
1631     for(;;) {
1632         s2k->mode = opt.s2k_mode;
1633         s2k->hash_algo = opt.s2k_digest_algo;
1634         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
1635                                  errtext, NULL);
1636         if( !dek ) {
1637             errtext = N_("passphrase not correctly repeated; try again");
1638             tty_printf(_("%s.\n"), _(errtext));
1639         }
1640         else if( !dek->keylen ) {
1641             xfree (dek); dek = NULL;
1642             xfree (s2k); s2k = NULL;
1643             tty_printf(_(
1644             "You don't want a passphrase - this is probably a *bad* idea!\n"
1645             "I will do it anyway.  You can change your passphrase at any time,\n"
1646             "using this program with the option \"--edit-key\".\n\n"));
1647             break;
1648         }
1649         else
1650             break; /* okay */
1651     }
1652     *ret_s2k = s2k;
1653     return dek;
1654 }
1655
1656
1657 static int
1658 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
1659            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate )
1660 {
1661     int rc=0;
1662
1663     if( !opt.batch )
1664         tty_printf(_(
1665 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1666 "some other action (type on the keyboard, move the mouse, utilize the\n"
1667 "disks) during the prime generation; this gives the random number\n"
1668 "generator a better chance to gain enough entropy.\n") );
1669
1670     if( algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E )
1671         rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1672     else if( algo == PUBKEY_ALGO_DSA )
1673         rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1674     else if( algo == PUBKEY_ALGO_RSA )
1675         rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1676     else
1677         BUG();
1678
1679 #ifdef ENABLE_COMMENT_PACKETS
1680     if( !rc ) {
1681         add_kbnode( pub_root,
1682                 make_comment_node("#created by GNUPG v" VERSION " ("
1683                                             PRINTABLE_OS_NAME ")"));
1684         add_kbnode( sec_root,
1685                 make_comment_node("#created by GNUPG v" VERSION " ("
1686                                             PRINTABLE_OS_NAME ")"));
1687     }
1688 #endif
1689     return rc;
1690 }
1691
1692
1693 /****************
1694  * Generate a new user id packet, or return NULL if canceled
1695  */
1696 PKT_user_id *
1697 generate_user_id()
1698 {
1699     PKT_user_id *uid;
1700     char *p;
1701     size_t n;
1702
1703     p = ask_user_id( 1 );
1704     if( !p )
1705         return NULL;
1706     n = strlen(p);
1707     uid = xcalloc (1, sizeof *uid + n - 1 );
1708     uid->len = n;
1709     strcpy(uid->name, p);
1710     uid->ref = 1;
1711     return uid;
1712 }
1713
1714
1715 static void
1716 release_parameter_list( struct para_data_s *r )
1717 {
1718     struct para_data_s *r2;
1719
1720     for( ; r ; r = r2 ) {
1721         r2 = r->next;
1722         if( r->key == pPASSPHRASE_DEK )
1723             xfree ( r->u.dek );
1724         else if( r->key == pPASSPHRASE_S2K )
1725             xfree ( r->u.s2k );
1726
1727         xfree (r);
1728     }
1729 }
1730
1731 static struct para_data_s *
1732 get_parameter( struct para_data_s *para, enum para_name key )
1733 {
1734     struct para_data_s *r;
1735
1736     for( r = para; r && r->key != key; r = r->next )
1737         ;
1738     return r;
1739 }
1740
1741 static const char *
1742 get_parameter_value( struct para_data_s *para, enum para_name key )
1743 {
1744     struct para_data_s *r = get_parameter( para, key );
1745     return (r && *r->u.value)? r->u.value : NULL;
1746 }
1747
1748 static int
1749 get_parameter_algo( struct para_data_s *para, enum para_name key )
1750 {
1751     int i;
1752     struct para_data_s *r = get_parameter( para, key );
1753     if( !r )
1754         return -1;
1755     if( isdigit( *r->u.value ) )
1756         i = atoi( r->u.value );
1757     else
1758         i = openpgp_pk_map_name ( r->u.value );
1759     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
1760       i = 0; /* we don't want to allow generation of these algorithms */
1761     return i;
1762 }
1763
1764 /* 
1765  * parse the usage parameter and set the keyflags.  Return true on error.
1766  */
1767 static int
1768 parse_parameter_usage (const char *fname,
1769                        struct para_data_s *para, enum para_name key)
1770 {
1771     struct para_data_s *r = get_parameter( para, key );
1772     char *p, *pn;
1773     unsigned int use;
1774
1775     if( !r )
1776         return 0; /* none (this is an optional parameter)*/
1777     
1778     use = 0;
1779     pn = r->u.value;
1780     while ( (p = strsep (&pn, " \t,")) ) {
1781         if ( !*p)
1782             ;
1783         else if ( !ascii_strcasecmp (p, "sign") )
1784             use |= PUBKEY_USAGE_SIG;
1785         else if ( !ascii_strcasecmp (p, "encrypt") )
1786             use |= PUBKEY_USAGE_ENC;
1787         else {
1788             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
1789             return -1; /* error */
1790         }
1791     }
1792     r->u.usage = use;
1793     return 0;
1794 }
1795
1796 static int
1797 parse_revocation_key (const char *fname,
1798                       struct para_data_s *para, enum para_name key)
1799 {
1800   struct para_data_s *r = get_parameter( para, key );
1801   struct revocation_key revkey;
1802   char *pn;
1803   int i;
1804
1805   if( !r )
1806     return 0; /* none (this is an optional parameter) */
1807
1808   pn = r->u.value;
1809
1810   revkey.class=0x80;
1811   revkey.algid=atoi(pn);
1812   if(!revkey.algid)
1813     goto fail;
1814
1815   /* Skip to the fpr */
1816   while(*pn && *pn!=':')
1817     pn++;
1818
1819   if(*pn!=':')
1820     goto fail;
1821
1822   pn++;
1823
1824   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
1825     {
1826       int c=hextobyte(pn);
1827       if(c==-1)
1828         goto fail;
1829
1830       revkey.fpr[i]=c;
1831     }
1832
1833   /* skip to the tag */
1834   while(*pn && *pn!='s' && *pn!='S')
1835     pn++;
1836
1837   if(ascii_strcasecmp(pn,"sensitive")==0)
1838     revkey.class|=0x40;
1839
1840   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
1841
1842   return 0;
1843
1844   fail:
1845   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
1846   return -1; /* error */
1847 }
1848
1849
1850 static u32
1851 get_parameter_u32( struct para_data_s *para, enum para_name key )
1852 {
1853     struct para_data_s *r = get_parameter( para, key );
1854
1855     if( !r )
1856         return 0;
1857     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
1858         return r->u.expire;
1859     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
1860         return r->u.usage;
1861
1862     return (unsigned int)strtoul( r->u.value, NULL, 10 );
1863 }
1864
1865 static unsigned int
1866 get_parameter_uint( struct para_data_s *para, enum para_name key )
1867 {
1868     return get_parameter_u32( para, key );
1869 }
1870
1871 static DEK *
1872 get_parameter_dek( struct para_data_s *para, enum para_name key )
1873 {
1874     struct para_data_s *r = get_parameter( para, key );
1875     return r? r->u.dek : NULL;
1876 }
1877
1878 static STRING2KEY *
1879 get_parameter_s2k( struct para_data_s *para, enum para_name key )
1880 {
1881     struct para_data_s *r = get_parameter( para, key );
1882     return r? r->u.s2k : NULL;
1883 }
1884
1885 static struct revocation_key *
1886 get_parameter_revkey( struct para_data_s *para, enum para_name key )
1887 {
1888     struct para_data_s *r = get_parameter( para, key );
1889     return r? &r->u.revkey : NULL;
1890 }
1891
1892 static int
1893 proc_parameter_file( struct para_data_s *para, const char *fname,
1894                      struct output_control_s *outctrl, int card )
1895 {
1896     struct para_data_s *r;
1897     const char *s1, *s2, *s3;
1898     size_t n;
1899     char *p;
1900     int i;
1901
1902     /* check that we have all required parameters */
1903     assert( get_parameter( para, pKEYTYPE ) );
1904     i = get_parameter_algo( para, pKEYTYPE );
1905     if( i < 1 || openpgp_pk_test_algo ( i, PUBKEY_USAGE_SIG ) ) {
1906         r = get_parameter( para, pKEYTYPE );
1907         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1908         return -1;
1909     }
1910
1911     if (parse_parameter_usage (fname, para, pKEYUSAGE))
1912         return -1;
1913
1914     i = get_parameter_algo( para, pSUBKEYTYPE );
1915     if( i > 0 && openpgp_pk_test_algo ( i, 0 ) ) {
1916         r = get_parameter( para, pSUBKEYTYPE );
1917         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1918         return -1;
1919     }
1920     if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
1921         return -1;
1922
1923
1924     if( !get_parameter_value( para, pUSERID ) ) {
1925         /* create the formatted user ID */
1926         s1 = get_parameter_value( para, pNAMEREAL );
1927         s2 = get_parameter_value( para, pNAMECOMMENT );
1928         s3 = get_parameter_value( para, pNAMEEMAIL );
1929         if( s1 || s2 || s3 ) {
1930             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
1931             r = xcalloc (1, sizeof *r + n + 20 );
1932             r->key = pUSERID;
1933             p = r->u.value;
1934             if( s1 )
1935                 p = stpcpy(p, s1 );
1936             if( s2 )
1937                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
1938             if( s3 )
1939                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
1940             r->next = para;
1941             para = r;
1942         }
1943     }
1944
1945     /* Set preferences, if any. */
1946     keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
1947
1948     /* Set revoker, if any. */
1949     if (parse_revocation_key (fname, para, pREVOKER))
1950       return -1;
1951
1952     /* make DEK and S2K from the Passphrase */
1953     r = get_parameter( para, pPASSPHRASE );
1954     if( r && *r->u.value ) {
1955         /* we have a plain text passphrase - create a DEK from it.
1956          * It is a little bit ridiculous to keep it in secure memory
1957          * but because we do this always, why not here. */
1958         STRING2KEY *s2k;
1959         DEK *dek;
1960
1961         s2k = xmalloc_secure ( sizeof *s2k );
1962         s2k->mode = opt.s2k_mode;
1963         s2k->hash_algo = opt.s2k_digest_algo;
1964         set_next_passphrase( r->u.value );
1965         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
1966                                  NULL, NULL);
1967         set_next_passphrase( NULL );
1968         assert( dek );
1969         memset( r->u.value, 0, strlen(r->u.value) );
1970
1971         r = xcalloc (1, sizeof *r );
1972         r->key = pPASSPHRASE_S2K;
1973         r->u.s2k = s2k;
1974         r->next = para;
1975         para = r;
1976         r = xcalloc (1, sizeof *r );
1977         r->key = pPASSPHRASE_DEK;
1978         r->u.dek = dek;
1979         r->next = para;
1980         para = r;
1981     }
1982
1983     /* make KEYEXPIRE from Expire-Date */
1984     r = get_parameter( para, pEXPIREDATE );
1985     if( r && *r->u.value ) {
1986         i = parse_expire_string( r->u.value );
1987         if( i < 0 ) {
1988             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
1989             return -1;
1990         }
1991         r->u.expire = i * 86400L;
1992         r->key = pKEYEXPIRE;  /* change hat entry */
1993         /* also set it for the subkey */
1994         r = xcalloc (1, sizeof *r + 20 );
1995         r->key = pSUBKEYEXPIRE;
1996         r->u.expire = i * 86400L;
1997         r->next = para;
1998         para = r;
1999     }
2000
2001     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2002         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2003         return -1;
2004     }
2005
2006     do_generate_keypair( para, outctrl, card);
2007     return 0;
2008 }
2009
2010
2011 /****************
2012  * Kludge to allow non interactive key generation controlled
2013  * by a parameter file (which currently is only stdin)
2014  * Note, that string parameters are expected to be in UTF-8
2015  */
2016 static void
2017 read_parameter_file( const char *fname )
2018 {
2019     static struct { const char *name;
2020                     enum para_name key;
2021     } keywords[] = {
2022         { "Key-Type",       pKEYTYPE},
2023         { "Key-Length",     pKEYLENGTH },
2024         { "Key-Usage",      pKEYUSAGE },
2025         { "Subkey-Type",    pSUBKEYTYPE },
2026         { "Subkey-Length",  pSUBKEYLENGTH },
2027         { "Subkey-Usage",   pSUBKEYUSAGE },
2028         { "Name-Real",      pNAMEREAL },
2029         { "Name-Email",     pNAMEEMAIL },
2030         { "Name-Comment",   pNAMECOMMENT },
2031         { "Expire-Date",    pEXPIREDATE },
2032         { "Passphrase",     pPASSPHRASE },
2033         { "Preferences",    pPREFERENCES },
2034         { "Revoker",        pREVOKER },
2035         { NULL, 0 }
2036     };
2037     FILE *fp;
2038     char line[1024], *p;
2039     int lnr;
2040     const char *err = NULL;
2041     struct para_data_s *para, *r;
2042     int i;
2043     struct output_control_s outctrl;
2044
2045     memset( &outctrl, 0, sizeof( outctrl ) );
2046
2047     if( !fname || !*fname || !strcmp(fname,"-") ) {
2048         fp = stdin;
2049         fname = "-";
2050     }
2051     else {
2052         fp = fopen( fname, "r" );
2053         if( !fp ) {
2054             log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
2055             return;
2056         }
2057     }
2058
2059     lnr = 0;
2060     err = NULL;
2061     para = NULL;
2062     while( fgets( line, DIM(line)-1, fp ) ) {
2063         char *keyword, *value;
2064
2065         lnr++;
2066         if( *line && line[strlen(line)-1] != '\n' ) {
2067             err = "line too long";
2068             break;
2069         }
2070         for( p = line; isspace(*(byte*)p); p++ )
2071             ;
2072         if( !*p || *p == '#' )
2073             continue;
2074         keyword = p;
2075         if( *keyword == '%' ) {
2076             for( ; !isspace(*(byte*)p); p++ )
2077                 ;
2078             if( *p )
2079                 *p++ = 0;
2080             for( ; isspace(*(byte*)p); p++ )
2081                 ;
2082             value = p;
2083             trim_trailing_ws( value, strlen(value) );
2084             if( !ascii_strcasecmp( keyword, "%echo" ) )
2085                 log_info("%s\n", value );
2086             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2087                 outctrl.dryrun = 1;
2088             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2089                 outctrl.lnr = lnr;
2090                 proc_parameter_file( para, fname, &outctrl, 0 );
2091                 release_parameter_list( para );
2092                 para = NULL;
2093             }
2094             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2095                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2096                     ; /* still the same file - ignore it */
2097                 else {
2098                     xfree ( outctrl.pub.newfname );
2099                     outctrl.pub.newfname = xstrdup ( value );
2100                     outctrl.use_files = 1;
2101                 }
2102             }
2103             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2104                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2105                     ; /* still the same file - ignore it */
2106                 else {
2107                    xfree ( outctrl.sec.newfname );
2108                    outctrl.sec.newfname = xstrdup ( value );
2109                    outctrl.use_files = 1;
2110                 }
2111             }
2112             else
2113                 log_info("skipping control `%s' (%s)\n", keyword, value );
2114
2115
2116             continue;
2117         }
2118
2119
2120         if( !(p = strchr( p, ':' )) || p == keyword ) {
2121             err = "missing colon";
2122             break;
2123         }
2124         if( *p )
2125             *p++ = 0;
2126         for( ; isspace(*(byte*)p); p++ )
2127             ;
2128         if( !*p ) {
2129             err = "missing argument";
2130             break;
2131         }
2132         value = p;
2133         trim_trailing_ws( value, strlen(value) );
2134
2135         for(i=0; keywords[i].name; i++ ) {
2136             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2137                 break;
2138         }
2139         if( !keywords[i].name ) {
2140             err = "unknown keyword";
2141             break;
2142         }
2143         if( keywords[i].key != pKEYTYPE && !para ) {
2144             err = "parameter block does not start with \"Key-Type\"";
2145             break;
2146         }
2147
2148         if( keywords[i].key == pKEYTYPE && para ) {
2149             outctrl.lnr = lnr;
2150             proc_parameter_file( para, fname, &outctrl, 0 );
2151             release_parameter_list( para );
2152             para = NULL;
2153         }
2154         else {
2155             for( r = para; r; r = r->next ) {
2156                 if( r->key == keywords[i].key )
2157                     break;
2158             }
2159             if( r ) {
2160                 err = "duplicate keyword";
2161                 break;
2162             }
2163         }
2164         r = xcalloc (1, sizeof *r + strlen( value ) );
2165         r->lnr = lnr;
2166         r->key = keywords[i].key;
2167         strcpy( r->u.value, value );
2168         r->next = para;
2169         para = r;
2170     }
2171     if( err )
2172         log_error("%s:%d: %s\n", fname, lnr, err );
2173     else if( ferror(fp) ) {
2174         log_error("%s:%d: read error: %s\n", fname, lnr, strerror(errno) );
2175     }
2176     else if( para ) {
2177         outctrl.lnr = lnr;
2178         proc_parameter_file( para, fname, &outctrl, 0 );
2179     }
2180
2181     if( outctrl.use_files ) { /* close open streams */
2182         iobuf_close( outctrl.pub.stream );
2183         iobuf_close( outctrl.sec.stream );
2184         xfree ( outctrl.pub.fname );
2185         xfree ( outctrl.pub.newfname );
2186         xfree ( outctrl.sec.fname );
2187         xfree ( outctrl.sec.newfname );
2188     }
2189
2190     release_parameter_list( para );
2191     if( strcmp( fname, "-" ) )
2192         fclose(fp);
2193 }
2194
2195
2196 /****************
2197  * Generate a keypair
2198  * (fname is only used in batch mode)
2199  */
2200 void
2201 generate_keypair( const char *fname )
2202 {
2203   unsigned int nbits;
2204   char *uid = NULL;
2205   DEK *dek;
2206   STRING2KEY *s2k;
2207   int algo;
2208   unsigned int use;
2209   int both = 0;
2210   int card = 0;
2211   u32 expire;
2212   struct para_data_s *para = NULL;
2213   struct para_data_s *r;
2214   struct output_control_s outctrl;
2215   char *serialno = NULL;
2216
2217   memset (&outctrl, 0, sizeof (outctrl));
2218
2219   if (opt.batch)
2220     {
2221       read_parameter_file( fname );
2222       return;
2223     }
2224
2225   do
2226     {
2227       xfree (serialno); serialno = NULL;
2228       card = check_smartcard (&serialno);
2229       if (card < 0)
2230         return;
2231     }
2232   while (card > 1);
2233
2234   if (serialno)
2235     {
2236       r = xcalloc (1, sizeof *r + strlen (serialno) );
2237       r->key = pSERIALNO;
2238       strcpy( r->u.value, serialno);
2239       r->next = para;
2240       para = r;
2241       xfree (serialno); serialno = NULL;
2242     }
2243
2244   if (card)
2245     {
2246       algo = PUBKEY_ALGO_RSA;
2247
2248       r = xcalloc (1, sizeof *r + 20 );
2249       r->key = pKEYTYPE;
2250       sprintf( r->u.value, "%d", algo );
2251       r->next = para;
2252       para = r;
2253       r = xcalloc (1, sizeof *r + 20 );
2254       r->key = pKEYUSAGE;
2255       strcpy (r->u.value, "sign");
2256       r->next = para;
2257       para = r;
2258
2259       r = xcalloc (1, sizeof *r + 20 );
2260       r->key = pSUBKEYTYPE;
2261       sprintf( r->u.value, "%d", algo );
2262       r->next = para;
2263       para = r;
2264       r = xcalloc (1, sizeof *r + 20 );
2265       r->key = pSUBKEYUSAGE;
2266       strcpy (r->u.value, "encrypt");
2267       r->next = para;
2268       para = r;
2269
2270       r = xcalloc (1, sizeof *r + 20 );
2271       r->key = pAUTHKEYTYPE;
2272       sprintf( r->u.value, "%d", algo );
2273       r->next = para;
2274       para = r;
2275     }
2276   else
2277     {
2278       algo = ask_algo (0, &use);
2279       
2280       if (!algo)
2281         { /* default: DSA with ElG subkey of the specified size */
2282           both = 1;
2283           r = xcalloc (1, sizeof *r + 20 );
2284           r->key = pKEYTYPE;
2285           sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2286           r->next = para;
2287           para = r;
2288           tty_printf(_("DSA keypair will have 1024 bits.\n"));
2289           r = xcalloc (1, sizeof *r + 20 );
2290           r->key = pKEYLENGTH;
2291           strcpy( r->u.value, "1024" );
2292           r->next = para;
2293           para = r;
2294           
2295           algo = PUBKEY_ALGO_ELGAMAL_E;
2296           r = xcalloc (1, sizeof *r + 20 );
2297           r->key = pSUBKEYTYPE;
2298           sprintf( r->u.value, "%d", algo );
2299           r->next = para;
2300           para = r;
2301         }
2302       else 
2303         {
2304           r = xcalloc (1, sizeof *r + 20 );
2305           r->key = pKEYTYPE;
2306           sprintf( r->u.value, "%d", algo );
2307           r->next = para;
2308           para = r;
2309           
2310           if (use)
2311             {
2312               r = xcalloc (1, sizeof *r + 20 );
2313               r->key = pKEYUSAGE;
2314               sprintf( r->u.value, "%s%s",
2315                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
2316                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"" );
2317               r->next = para;
2318               para = r;
2319             }
2320         }
2321
2322       nbits = ask_keysize( algo );
2323       r = xcalloc (1, sizeof *r + 20 );
2324       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2325       sprintf( r->u.value, "%u", nbits);
2326       r->next = para;
2327       para = r;
2328     }
2329
2330   expire = ask_expire_interval(0);
2331   r = xcalloc (1, sizeof *r + 20 );
2332   r->key = pKEYEXPIRE;
2333   r->u.expire = expire;
2334   r->next = para;
2335   para = r;
2336   r = xcalloc (1, sizeof *r + 20 );
2337   r->key = pSUBKEYEXPIRE;
2338   r->u.expire = expire;
2339   r->next = para;
2340   para = r;
2341   
2342   uid = ask_user_id(0);
2343   if (!uid)
2344     {
2345       log_error(_("Key generation canceled.\n"));
2346       release_parameter_list( para );
2347       return;
2348     }
2349   r = xcalloc (1, sizeof *r + strlen(uid) );
2350   r->key = pUSERID;
2351   strcpy( r->u.value, uid );
2352   r->next = para;
2353   para = r;
2354
2355   dek = card? NULL : ask_passphrase( &s2k );
2356   if (dek)
2357     {
2358       r = xcalloc (1, sizeof *r );
2359       r->key = pPASSPHRASE_DEK;
2360       r->u.dek = dek;
2361       r->next = para;
2362       para = r;
2363       r = xcalloc (1, sizeof *r );
2364       r->key = pPASSPHRASE_S2K;
2365       r->u.s2k = s2k;
2366       r->next = para;
2367       para = r;
2368     }
2369   
2370   proc_parameter_file (para, "[internal]", &outctrl, card);
2371   release_parameter_list (para);
2372 }
2373
2374
2375 static void
2376 print_status_key_created (int letter, PKT_public_key *pk)
2377 {
2378   byte array[MAX_FINGERPRINT_LEN], *s;
2379   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
2380   size_t i, n;
2381   
2382   p = buf;
2383   *p++ = letter;
2384   *p++ = ' ';
2385   fingerprint_from_pk (pk, array, &n);
2386   s = array;
2387   for (i=0; i < n ; i++, s++, p += 2)
2388     sprintf (p, "%02X", *s);
2389   *p = 0;
2390   write_status_text (STATUS_KEY_CREATED, buf);
2391 }
2392
2393
2394
2395 static void
2396 do_generate_keypair (struct para_data_s *para,
2397                      struct output_control_s *outctrl, int card)
2398 {
2399   KBNODE pub_root = NULL;
2400   KBNODE sec_root = NULL;
2401   PKT_secret_key *sk = NULL;
2402   const char *s;
2403   struct revocation_key *revkey;
2404   int rc;
2405   int did_sub = 0;
2406
2407   if (outctrl->dryrun)
2408     {
2409       log_info ("dry-run mode - key generation skipped\n");
2410       return;
2411     }
2412
2413
2414   if (outctrl->use_files)
2415     {
2416       if (outctrl->pub.newfname)
2417         {
2418           iobuf_close (outctrl->pub.stream);
2419           outctrl->pub.stream = NULL;
2420           xfree (outctrl->pub.fname);
2421           outctrl->pub.fname = outctrl->pub.newfname;
2422           outctrl->pub.newfname = NULL;
2423
2424           outctrl->pub.stream = iobuf_create (outctrl->pub.fname);
2425           if (!outctrl->pub.stream)
2426             {
2427               log_error ("can't create `%s': %s\n", outctrl->pub.newfname,
2428                          strerror (errno));
2429               return;
2430             }
2431           if (opt.armor)
2432             {
2433               outctrl->pub.afx.what = 1;
2434               iobuf_push_filter (outctrl->pub.stream, armor_filter,
2435                                  &outctrl->pub.afx);
2436             }
2437         }
2438       if (outctrl->sec.newfname)
2439         {
2440           iobuf_close (outctrl->sec.stream);
2441           outctrl->sec.stream = NULL;
2442           xfree (outctrl->sec.fname);
2443           outctrl->sec.fname = outctrl->sec.newfname;
2444           outctrl->sec.newfname = NULL;
2445
2446           outctrl->sec.stream = iobuf_create (outctrl->sec.fname);
2447           if (!outctrl->sec.stream)
2448             {
2449               log_error ("can't create `%s': %s\n", outctrl->sec.newfname,
2450                          strerror (errno));
2451               return;
2452             }
2453           if (opt.armor)
2454             {
2455               outctrl->sec.afx.what = 5;
2456               iobuf_push_filter (outctrl->sec.stream, armor_filter,
2457                                  &outctrl->sec.afx);
2458             }
2459         }
2460       assert (outctrl->pub.stream);
2461       assert (outctrl->sec.stream);
2462       if (opt.verbose)
2463         {
2464           log_info (_("writing public key to `%s'\n"), outctrl->pub.fname);
2465           if (card)
2466             log_info (_("writing secret key stub to `%s'\n"),
2467                       outctrl->sec.fname);
2468           else
2469             log_info (_("writing secret key to `%s'\n"), outctrl->sec.fname);
2470         }
2471     }
2472
2473
2474   /* We create the packets as a tree of kbnodes. Because the structure
2475    * we create is known in advance we simply generate a linked list.
2476    * The first packet is a dummy comment packet which we flag
2477    * as deleted.  The very first packet must always be a KEY packet.
2478    */
2479   pub_root = make_comment_node ("#");
2480   delete_kbnode (pub_root);
2481   sec_root = make_comment_node ("#");
2482   delete_kbnode (sec_root);
2483   if (!card)
2484     {
2485       rc = do_create (get_parameter_algo (para, pKEYTYPE),
2486                       get_parameter_uint (para, pKEYLENGTH),
2487                       pub_root, sec_root,
2488                       get_parameter_dek (para, pPASSPHRASE_DEK),
2489                       get_parameter_s2k (para, pPASSPHRASE_S2K),
2490                       &sk, get_parameter_u32 (para, pKEYEXPIRE));
2491     }
2492   else
2493     {
2494       rc = gen_card_key (PUBKEY_ALGO_RSA, 1, pub_root, sec_root,
2495                          get_parameter_u32 (para, pKEYEXPIRE), para);
2496       if (!rc)
2497         {
2498           sk = sec_root->next->pkt->pkt.secret_key;
2499           assert (sk);
2500         }
2501       
2502     }
2503
2504   if (!rc && (revkey = get_parameter_revkey (para, pREVOKER)))
2505     {
2506       rc = write_direct_sig (pub_root, pub_root, sk, revkey);
2507       if (!rc)
2508         write_direct_sig (sec_root, pub_root, sk, revkey);
2509     }
2510
2511   if (!rc && (s = get_parameter_value (para, pUSERID)))
2512     {
2513       write_uid (pub_root, s);
2514       if (!rc)
2515         write_uid (sec_root, s);
2516       if (!rc)
2517         rc = write_selfsig (pub_root, pub_root, sk,
2518                             get_parameter_uint (para, pKEYUSAGE));
2519       if (!rc)
2520         rc = write_selfsig (sec_root, pub_root, sk,
2521                             get_parameter_uint (para, pKEYUSAGE));
2522     }
2523
2524   if (get_parameter (para, pSUBKEYTYPE))
2525     {
2526       if (!card)
2527         {
2528           rc = do_create (get_parameter_algo (para, pSUBKEYTYPE),
2529                           get_parameter_uint (para, pSUBKEYLENGTH),
2530                           pub_root, sec_root,
2531                           get_parameter_dek (para, pPASSPHRASE_DEK),
2532                           get_parameter_s2k (para, pPASSPHRASE_S2K),
2533                           NULL, get_parameter_u32 (para, pSUBKEYEXPIRE));
2534         }
2535       else
2536         {
2537           rc = gen_card_key (PUBKEY_ALGO_RSA, 2, pub_root, sec_root,
2538                              get_parameter_u32 (para, pKEYEXPIRE), para);
2539         }
2540
2541       if (!rc)
2542         rc = write_keybinding (pub_root, pub_root, sk,
2543                                get_parameter_uint (para, pSUBKEYUSAGE));
2544       if (!rc)
2545         rc = write_keybinding (sec_root, pub_root, sk,
2546                                get_parameter_uint (para, pSUBKEYUSAGE));
2547       did_sub = 1;
2548     }
2549
2550   if (card && get_parameter (para, pAUTHKEYTYPE))
2551     {
2552       rc = gen_card_key (PUBKEY_ALGO_RSA, 3, pub_root, sec_root,
2553                          get_parameter_u32 (para, pKEYEXPIRE), para);
2554
2555       /* FIXME: Change the usage to AUTH. */
2556       if (!rc)
2557         rc = write_keybinding (pub_root, pub_root, sk, PUBKEY_USAGE_SIG);
2558       if (!rc)
2559         rc = write_keybinding (sec_root, pub_root, sk, PUBKEY_USAGE_SIG);
2560     }
2561
2562
2563   if (!rc && outctrl->use_files)
2564     {                           /* direct write to specified files */
2565       rc = write_keyblock (outctrl->pub.stream, pub_root);
2566       if (rc)
2567         log_error ("can't write public key: %s\n", gpg_strerror (rc));
2568       if (!rc)
2569         {
2570           rc = write_keyblock (outctrl->sec.stream, sec_root);
2571           if (rc)
2572             log_error ("can't write secret key: %s\n", gpg_strerror (rc));
2573         }
2574
2575     }
2576   else if (!rc)
2577     {                           /* write to the standard keyrings */
2578       KEYDB_HANDLE pub_hd = keydb_new (0);
2579       KEYDB_HANDLE sec_hd = keydb_new (1);
2580
2581       /* FIXME: we may have to create the keyring first */
2582       rc = keydb_locate_writable (pub_hd, NULL);
2583       if (rc)
2584         log_error (_("no writable public keyring found: %s\n"),
2585                    gpg_strerror (rc));
2586
2587       if (!rc)
2588         {
2589           rc = keydb_locate_writable (sec_hd, NULL);
2590           if (rc)
2591             log_error (_("no writable secret keyring found: %s\n"),
2592                        gpg_strerror (rc));
2593         }
2594
2595       if (!rc && opt.verbose)
2596         {
2597           log_info (_("writing public key to `%s'\n"),
2598                     keydb_get_resource_name (pub_hd));
2599           if (card)
2600             log_info (_("writing secret key stub to `%s'\n"),
2601                       keydb_get_resource_name (sec_hd));
2602           else
2603             log_info (_("writing secret key to `%s'\n"),
2604                       keydb_get_resource_name (sec_hd));
2605         }
2606
2607       if (!rc)
2608         {
2609           rc = keydb_insert_keyblock (pub_hd, pub_root);
2610           if (rc)
2611             log_error (_("error writing public keyring `%s': %s\n"),
2612                        keydb_get_resource_name (pub_hd), gpg_strerror (rc));
2613         }
2614
2615       if (!rc)
2616         {
2617           rc = keydb_insert_keyblock (sec_hd, sec_root);
2618           if (rc)
2619             log_error (_("error writing secret keyring `%s': %s\n"),
2620                        keydb_get_resource_name (pub_hd), gpg_strerror (rc));
2621         }
2622
2623       keydb_release (pub_hd);
2624       keydb_release (sec_hd);
2625
2626       if (!rc)
2627         {
2628           int no_enc_rsa =
2629             get_parameter_algo (para, pKEYTYPE) == PUBKEY_ALGO_RSA
2630             && get_parameter_uint (para, pKEYUSAGE)
2631             && !(get_parameter_uint (para, pKEYUSAGE) & PUBKEY_USAGE_ENC);
2632           PKT_public_key *pk = find_kbnode (pub_root,
2633                                             PKT_PUBLIC_KEY)->pkt->pkt.
2634             public_key;
2635
2636           update_ownertrust (pk,
2637                              ((get_ownertrust (pk) & ~TRUST_MASK)
2638                               | TRUST_ULTIMATE));
2639
2640           if (!opt.batch)
2641             {
2642               tty_printf (_("public and secret key created and signed.\n"));
2643               tty_printf (_("key marked as ultimately trusted.\n"));
2644               tty_printf ("\n");
2645               list_keyblock (pub_root, 0, 1, NULL);
2646             }
2647
2648
2649           if (!opt.batch
2650               && (get_parameter_algo (para, pKEYTYPE) == PUBKEY_ALGO_DSA
2651                   || no_enc_rsa) && !get_parameter (para, pSUBKEYTYPE))
2652             {
2653               tty_printf (_("Note that this key cannot be used for "
2654                             "encryption.  You may want to use\n"
2655                             "the command \"--edit-key\" to generate a "
2656                             "secondary key for this purpose.\n"));
2657             }
2658         }
2659     }
2660
2661   if (rc)
2662     {
2663       if (opt.batch)
2664         log_error ("key generation failed: %s\n", gpg_strerror (rc));
2665       else
2666         tty_printf (_("Key generation failed: %s\n"), gpg_strerror (rc));
2667     }
2668   else
2669     {
2670       PKT_public_key *pk = find_kbnode (pub_root,
2671                                         PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2672       print_status_key_created (did_sub ? 'B' : 'P', pk);
2673     }
2674
2675   release_kbnode (pub_root);
2676   release_kbnode (sec_root);
2677   if (sk && !card)         /* The unprotected secret key unless we have */
2678     free_secret_key (sk);  /* shallow copy in card mode. */
2679 }
2680
2681
2682 /****************
2683  * add a new subkey to an existing key.
2684  * Returns true if a new key has been generated and put into the keyblocks.
2685  */
2686 int
2687 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
2688 {
2689     int okay=0, rc=0;
2690     KBNODE node;
2691     PKT_secret_key *sk = NULL; /* this is the primary sk */
2692     int algo;
2693     unsigned int use;
2694     u32 expire;
2695     unsigned nbits;
2696     char *passphrase = NULL;
2697     DEK *dek = NULL;
2698     STRING2KEY *s2k = NULL;
2699     u32 cur_time;
2700
2701     /* break out the primary secret key */
2702     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
2703     if( !node ) {
2704         log_error("Oops; secret key not found anymore!\n");
2705         goto leave;
2706     }
2707
2708     /* make a copy of the sk to keep the protected one in the keyblock */
2709     sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
2710
2711     cur_time = make_timestamp();
2712     if( sk->timestamp > cur_time ) {
2713         ulong d = sk->timestamp - cur_time;
2714         log_info( d==1 ? _("key has been created %lu second "
2715                            "in future (time warp or clock problem)\n")
2716                        : _("key has been created %lu seconds "
2717                            "in future (time warp or clock problem)\n"), d );
2718         if( !opt.ignore_time_conflict ) {
2719             rc = GPG_ERR_TIME_CONFLICT;
2720             goto leave;
2721         }
2722     }
2723
2724     if (sk->version < 4) {
2725         log_info (_("NOTE: creating subkeys for v3 keys "
2726                     "is not OpenPGP compliant\n"));
2727         goto leave;
2728     }
2729
2730     /* unprotect to get the passphrase */
2731     switch( is_secret_key_protected( sk ) ) {
2732       case -1:
2733         rc = GPG_ERR_PUBKEY_ALGO;
2734         break;
2735       case 0:
2736         tty_printf("This key is not protected.\n");
2737         break;
2738       default:
2739         tty_printf("Key is protected.\n");
2740         rc = check_secret_key( sk, 0 );
2741         if( !rc )
2742             passphrase = get_last_passphrase();
2743         break;
2744     }
2745     if( rc )
2746         goto leave;
2747
2748
2749     algo = ask_algo( 1, &use );
2750     assert(algo);
2751     nbits = ask_keysize( algo );
2752     expire = ask_expire_interval(0);
2753     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
2754                                                   _("Really create? ") ) )
2755         goto leave;
2756
2757     if( passphrase ) {
2758         s2k = xmalloc_secure ( sizeof *s2k );
2759         s2k->mode = opt.s2k_mode;
2760         s2k->hash_algo = opt.s2k_digest_algo;
2761         set_next_passphrase( passphrase );
2762         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2763                                  NULL, NULL );
2764     }
2765
2766     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
2767                                       dek, s2k, NULL, expire );
2768     if( !rc )
2769         rc = write_keybinding(pub_keyblock, pub_keyblock, sk, use);
2770     if( !rc )
2771         rc = write_keybinding(sec_keyblock, pub_keyblock, sk, use);
2772     if( !rc ) {
2773         okay = 1;
2774         write_status_text (STATUS_KEY_CREATED, "S");
2775     }
2776
2777   leave:
2778     if( rc )
2779         log_error(_("Key generation failed: %s\n"), gpg_strerror (rc) );
2780     xfree ( passphrase );
2781     xfree ( dek );
2782     xfree ( s2k );
2783     if( sk ) /* release the copy of the (now unprotected) secret key */
2784         free_secret_key(sk);
2785     set_next_passphrase( NULL );
2786     return okay;
2787 }
2788
2789 /****************
2790  * Write a keyblock to an output stream
2791  */
2792 static int
2793 write_keyblock( iobuf_t out, KBNODE node )
2794 {
2795     for( ; node ; node = node->next ) {
2796         int rc = build_packet( out, node->pkt );
2797         if( rc ) {
2798             log_error("build_packet(%d) failed: %s\n",
2799                         node->pkt->pkttype, gpg_strerror (rc) );
2800             return rc;
2801         }
2802     }
2803     return 0;
2804 }
2805
2806 \f
2807 static void
2808 show_sha1_fpr (const unsigned char *fpr)
2809 {
2810   int i;
2811
2812   if (fpr)
2813     {
2814       for (i=0; i < 20 ; i+=2, fpr += 2 )
2815         {
2816           if (i == 10 )
2817             tty_printf (" ");
2818           tty_printf (" %02X%02X", *fpr, fpr[1]);
2819         }
2820     }
2821   else
2822     tty_printf (" [none]");
2823   tty_printf ("\n");
2824 }
2825
2826 static void
2827 show_smartcard (struct agent_card_info_s *info)
2828 {
2829   PKT_public_key *pk = xcalloc (1, sizeof *pk);
2830
2831   /* FIXME: Sanitize what we show. */
2832   tty_printf ("Name of cardholder: %s\n",
2833               info->disp_name && *info->disp_name? info->disp_name 
2834                                                  : "[not set]");
2835   tty_printf ("URL of public key : %s\n",
2836               info->pubkey_url && *info->pubkey_url? info->pubkey_url 
2837                                                  : "[not set]");
2838   tty_printf ("Signature key ....:");
2839   show_sha1_fpr (info->fpr1valid? info->fpr1:NULL);
2840   tty_printf ("Encryption key....:");
2841   show_sha1_fpr (info->fpr2valid? info->fpr2:NULL);
2842   tty_printf ("Authentication key:");
2843   show_sha1_fpr (info->fpr3valid? info->fpr3:NULL);
2844
2845   if (info->fpr1valid && !get_pubkey_byfprint (pk, info->fpr1, 20))
2846     print_pubkey_info (NULL, pk);
2847
2848   free_public_key( pk );
2849 }
2850
2851
2852 static char *
2853 smartcard_get_one_name (const char *prompt1, const char *prompt2)
2854 {
2855   char *name;
2856   int i;
2857
2858   for (;;)
2859     {
2860       name = cpr_get (prompt1, prompt2);
2861       if (!name)
2862         return NULL;
2863       trim_spaces (name);
2864       cpr_kill_prompt ();
2865       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
2866         ;
2867
2868       /* The name must be in Latin-1 and not UTF-8 - lacking the code
2869          to ensure this we restrict it to ASCII. */
2870       if (name[i])
2871         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
2872       else if (strchr (name, '<'))
2873         tty_printf (_("Error: The \"<\" character may not be used.\n"));
2874       else if (strstr (name, "  "))
2875         tty_printf (_("Error: Double spaces are not allowed.\n"));    
2876       else
2877         return name;
2878       xfree (name);
2879     }
2880 }
2881
2882 static int
2883 smartcard_change_name (const char *current_name)
2884 {
2885   char *surname = NULL, *givenname = NULL;
2886   char *isoname, *p;
2887   int rc;
2888
2889   surname = smartcard_get_one_name ("keygen.smartcard.surname",
2890                                     _("Cardholder's surname: "));
2891   givenname = smartcard_get_one_name ("keygen.smartcard.givenname",
2892                                        _("Cardholder's given name: "));
2893   if (!surname || !givenname || (!*surname && !*givenname))
2894     {
2895       xfree (surname);
2896       xfree (givenname);
2897       return -1; /*canceled*/
2898     }
2899
2900   isoname = xmalloc ( strlen (surname) + 2 + strlen (givenname) + 1);
2901   strcpy (stpcpy (stpcpy (isoname, surname), "<<"), givenname);
2902   xfree (surname);
2903   xfree (givenname);
2904   for (p=isoname; *p; p++)
2905     if (*p == ' ')
2906       *p = '<';
2907
2908   log_debug ("setting Name to `%s'\n", isoname);
2909   rc = agent_scd_setattr ("DISP-NAME", isoname, strlen (isoname) );
2910   if (rc)
2911     log_error ("error setting Name: %s\n", gpg_strerror (rc));
2912
2913   xfree (isoname);
2914   return rc;
2915 }
2916
2917
2918 static int
2919 smartcard_change_url (const char *current_url)
2920 {
2921   char *url;
2922   int rc;
2923
2924   url = cpr_get ("keygen.smartcard.url", _("URL to retrieve public key: "));
2925   if (!url)
2926     return -1;
2927   trim_spaces (url);
2928   cpr_kill_prompt ();
2929
2930   rc = agent_scd_setattr ("PUBKEY-URL", url, strlen (url) );
2931   if (rc)
2932     log_error ("error setting URL: %s\n", gpg_strerror (rc));
2933   xfree (url);
2934   return rc;
2935 }
2936
2937 static int
2938 smartcard_change_login_data (void)
2939 {
2940   char *data;
2941   int rc;
2942
2943   data = cpr_get ("keygen.smartcard.login_data",
2944                   _("Login data (account name): "));
2945   if (!data)
2946     return -1;
2947   trim_spaces (data);
2948   cpr_kill_prompt ();
2949
2950   rc = agent_scd_setattr ("LOGIN-DATA", data, strlen (data) );
2951   if (rc)
2952     log_error ("error setting login data: %s\n", gpg_strerror (rc));
2953   xfree (data);
2954   return rc;
2955 }
2956
2957 static int
2958 smartcard_change_lang (void)
2959 {
2960   char *data, *p;
2961   int rc;
2962
2963   data = cpr_get ("keygen.smartcard.lang",
2964                   _("Language preferences: "));
2965   if (!data)
2966     return -1;
2967   trim_spaces (data);
2968   cpr_kill_prompt ();
2969
2970   if (strlen (data) > 8 || (strlen (data) & 1))
2971     {
2972       tty_printf (_("Error: invalid length of preference string.\n"));
2973       xfree (data);
2974       return -1;
2975     }
2976
2977   for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
2978     ;
2979   if (*p)
2980     {
2981       tty_printf (_("Error: invalid characters in preference string.\n"));
2982       xfree (data);
2983       return -1;
2984     }
2985
2986   rc = agent_scd_setattr ("DISP-LANG", data, strlen (data) );
2987   if (rc)
2988     log_error ("error setting lang: %s\n", gpg_strerror (rc));
2989   xfree (data);
2990   return rc;
2991 }
2992
2993
2994 static int
2995 smartcard_change_sex (void)
2996 {
2997   char *data;
2998   const char *str;
2999   int rc;
3000
3001   data = cpr_get ("keygen.smartcard.sex",
3002                   _("Sex ((M)ale, (F)emale or space): "));
3003   if (!data)
3004     return -1;
3005   trim_spaces (data);
3006   cpr_kill_prompt ();
3007
3008   if (!*data)
3009     str = "9";
3010   else if ((*data == 'M' || *data == 'm') && !data[1])
3011     str = "1";
3012   else if ((*data == 'F' || *data == 'f') && !data[1])
3013     str = "2";
3014   else 
3015     {
3016       tty_printf (_("Error: invalid response.\n"));
3017       xfree (data);
3018       return -1;
3019     }
3020      
3021   rc = agent_scd_setattr ("DISP-SEX", str, 1 );
3022   if (rc)
3023     log_error ("error setting sex: %s\n", gpg_strerror (rc));
3024   xfree (data);
3025   return rc;
3026 }
3027
3028
3029 /* Return true if the SHA1 fingerprint FPR consists only of zeroes. */
3030 static int
3031 fpr_is_zero (const char *fpr)
3032 {
3033   int i;
3034
3035   for (i=0; i < 20 && !fpr[i]; i++)
3036     ;
3037   return (i == 20);
3038 }
3039
3040 /* Check whether a smartcatrd is available and alow to select it as
3041    the target for key generation. 
3042    
3043    Return values: -1 = Quit generation
3044                    0 = No smartcard
3045                    1 = Generate keypair
3046 */
3047 static int
3048 check_smartcard (char **r_serialno)
3049 {
3050   struct agent_card_info_s info;
3051   int rc;
3052
3053   rc = agent_learn (&info);
3054   if (rc)
3055     {
3056       tty_printf (_("OpenPGP card not available: %s\n"),
3057                   gpg_strerror (rc));
3058       return 0;
3059     }
3060   
3061   tty_printf (_("OpenPGP card no. %s detected\n"),
3062               info.serialno? info.serialno : "[none]");
3063
3064
3065   for (;;)
3066     {
3067       char *answer;
3068       int reread = 0;
3069
3070       tty_printf ("\n");
3071       show_smartcard (&info);
3072
3073       tty_printf ("\n"
3074                   "N - change cardholder name\n"
3075                   "U - change public key URL\n"
3076                   "D - change login data\n"
3077                   "L - change language preferences\n"
3078                   "S - change sex\n"
3079                   "K - generate all keys\n"
3080                   "Q - quit\n"
3081                   "\n");
3082
3083       answer = cpr_get("keygen.smartcard.menu",_("Your selection? "));
3084       cpr_kill_prompt();
3085       if (strlen (answer) != 1)
3086         continue;
3087
3088       rc = 0;
3089       if ( *answer == 'N' || *answer == 'n')
3090         {
3091           if (!smartcard_change_name (info.disp_name))
3092             reread = 1;
3093         }
3094       else if ( *answer == 'U' || *answer == 'u')
3095         {
3096           if (!smartcard_change_url (info.pubkey_url))
3097             reread = 1;
3098         }
3099       else if ( *answer == 'D' || *answer == 'd')
3100         {
3101           if (!smartcard_change_login_data ())
3102             reread = 1;
3103         }
3104       else if ( *answer == 'L' || *answer == 'l')
3105         {
3106           if (!smartcard_change_lang ())
3107             reread = 1;
3108         }
3109       else if ( *answer == 'S' || *answer == 's')
3110         {
3111           if (!smartcard_change_sex ())
3112             reread = 1; 
3113         }
3114       else if ( *answer == 'K' || *answer == 'k')
3115         {
3116           if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
3117                || (info.fpr2valid && !fpr_is_zero (info.fpr2))
3118                || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
3119             {
3120               tty_printf ("\n");
3121               log_error ("WARNING: key does already exists!\n");
3122               tty_printf ("\n");
3123               if ( cpr_get_answer_is_yes( "keygen.card.replace_key",
3124                                           _("Replace existing key? ")))
3125                 {
3126                   rc = 1;
3127                   break;
3128                 }
3129             }
3130           else
3131             {
3132               rc = 1;
3133               break;
3134             }
3135         }
3136       else if ( *answer == 'q' || *answer == 'Q')
3137         {
3138           rc = -1;
3139           break;
3140         }
3141
3142       if (reread)
3143         {
3144           agent_release_card_info (&info);
3145           rc = agent_learn (&info);
3146           if (rc)
3147             {
3148               tty_printf (_("OpenPGP card not anymore available: %s\n"),
3149                           gpg_strerror (rc));
3150               g10_exit (1);
3151             }
3152           reread = 0;
3153         }
3154     }
3155
3156   if (r_serialno && rc > 0)
3157     {
3158       *r_serialno = info.serialno;
3159       info.serialno = NULL;
3160     }
3161   agent_release_card_info (&info);
3162
3163   return rc;
3164 }
3165
3166
3167
3168 static int
3169 gen_card_key (int algo, int keyno, KBNODE pub_root, KBNODE sec_root,
3170               u32 expireval, struct para_data_s *para)
3171 {
3172   int rc;
3173   const char *s;
3174   struct agent_card_genkey_s info;
3175   PACKET *pkt;
3176   PKT_secret_key *sk;
3177   PKT_public_key *pk;
3178
3179   assert (algo == PUBKEY_ALGO_RSA);
3180
3181   rc = agent_scd_genkey (&info, keyno, 1);
3182 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3183 /*      { */
3184 /*        tty_printf ("\n"); */
3185 /*        log_error ("WARNING: key does already exists!\n"); */
3186 /*        tty_printf ("\n"); */
3187 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3188 /*                                    _("Replace existing key? "))) */
3189 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3190 /*      } */
3191
3192   if (rc)
3193     {
3194       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3195       return rc;
3196     }
3197   if ( !info.n || !info.e )
3198     {
3199       log_error ("communication error with SCD\n");
3200       gcry_mpi_release (info.n);
3201       gcry_mpi_release (info.e);
3202       return gpg_error (GPG_ERR_GENERAL);
3203     }
3204   
3205
3206   pk = xcalloc (1, sizeof *pk );
3207   sk = xcalloc (1, sizeof *sk );
3208   sk->timestamp = pk->timestamp = info.created_at;
3209   sk->version = pk->version = 4;
3210   if (expireval)
3211       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3212   sk->pubkey_algo = pk->pubkey_algo = algo;
3213   pk->pkey[0] = info.n;
3214   pk->pkey[1] = info.e; 
3215   sk->skey[0] = gcry_mpi_copy (pk->pkey[0]);
3216   sk->skey[1] = gcry_mpi_copy (pk->pkey[1]);
3217   sk->skey[2] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
3218   sk->is_protected = 1;
3219   sk->protect.s2k.mode = 1002;
3220   s = get_parameter_value (para, pSERIALNO);
3221   if (s)
3222     {
3223       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3224            sk->protect.ivlen++, s += 2)
3225         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3226     }
3227
3228   pkt = xcalloc (1,sizeof *pkt);
3229   pkt->pkttype = keyno == 1 ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3230   pkt->pkt.public_key = pk;
3231   add_kbnode(pub_root, new_kbnode( pkt ));
3232
3233   pkt = xcalloc (1,sizeof *pkt);
3234   pkt->pkttype = keyno == 1 ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3235   pkt->pkt.secret_key = sk;
3236   add_kbnode(sec_root, new_kbnode( pkt ));
3237
3238   return 0;
3239 }
3240
3241
3242