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