Use passphrase caching for import and genkey.
[gnupg.git] / g10 / keygen.c
1 /* keygen.c - generate a key pair
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2007, 2009, 2010 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 3 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, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26 #include <errno.h>
27 #include <assert.h>
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <unistd.h>
31
32 #include "gpg.h"
33 #include "util.h"
34 #include "main.h"
35 #include "packet.h"
36 #include "cipher.h"
37 #include "ttyio.h"
38 #include "options.h"
39 #include "keydb.h"
40 #include "trustdb.h"
41 #include "status.h"
42 #include "i18n.h"
43 #include "keyserver-internal.h"
44 #include "call-agent.h"
45
46 /* The default algorithms.  If you change them remember to change them
47    also in gpg.c:gpgconf_list.  You should also check that the value
48    is inside the bounds enforced by ask_keysize and gen_xxx.  */
49 #define DEFAULT_STD_ALGO    GCRY_PK_RSA
50 #define DEFAULT_STD_KEYSIZE 2048
51
52
53 #define MAX_PREFS 30 
54
55 enum para_name {
56   pKEYTYPE,
57   pKEYLENGTH,
58   pKEYUSAGE,
59   pSUBKEYTYPE,
60   pSUBKEYLENGTH,
61   pSUBKEYUSAGE,
62   pAUTHKEYTYPE,
63   pNAMEREAL,
64   pNAMEEMAIL,
65   pNAMECOMMENT,
66   pPREFERENCES,
67   pREVOKER,
68   pUSERID,
69   pCREATIONDATE,
70   pKEYCREATIONDATE, /* Same in seconds since epoch.  */
71   pEXPIREDATE,
72   pKEYEXPIRE, /* in n seconds */
73   pSUBKEYEXPIRE, /* in n seconds */
74   pPASSPHRASE,
75   pPASSPHRASE_DEK,
76   pPASSPHRASE_S2K,
77   pSERIALNO,
78   pBACKUPENCDIR,
79   pHANDLE,
80   pKEYSERVER
81 };
82
83 struct para_data_s {
84     struct para_data_s *next;
85     int lnr;
86     enum para_name key;
87     union {
88         DEK *dek;
89         STRING2KEY *s2k;
90         u32 expire;
91         u32 creation;
92         unsigned int usage;
93         struct revocation_key revkey;
94         char value[1];
95     } u;
96 };
97
98 struct output_control_s {
99     int lnr;
100     int dryrun;
101     int ask_passphrase;
102     int use_files;
103     struct {
104         char  *fname;
105         char  *newfname;
106         IOBUF stream;
107         armor_filter_context_t *afx;
108     } pub;
109     struct {
110         char  *fname;
111         char  *newfname;
112         IOBUF stream;
113         armor_filter_context_t *afx;
114     } sec;
115 };
116
117
118 struct opaque_data_usage_and_pk {
119     unsigned int usage;
120     PKT_public_key *pk;
121 };
122
123
124 static int prefs_initialized = 0;
125 static byte sym_prefs[MAX_PREFS];
126 static int nsym_prefs;
127 static byte hash_prefs[MAX_PREFS];
128 static int nhash_prefs;
129 static byte zip_prefs[MAX_PREFS];
130 static int nzip_prefs;
131 static int mdc_available,ks_modify;
132
133 static void do_generate_keypair( struct para_data_s *para,
134                                  struct output_control_s *outctrl, int card );
135 static int write_keyblock (iobuf_t out, kbnode_t node);
136 static int gen_card_key (int algo, int keyno, int is_primary, kbnode_t pub_root,
137                          u32 *timestamp, u32 expireval,
138                          struct para_data_s *para);
139 static int gen_card_key_with_backup (int algo, int keyno, int is_primary,
140                                      kbnode_t pub_root, u32 timestamp,
141                                      u32 expireval, struct para_data_s *para,
142                                      const char *backup_dir);
143
144
145 static void
146 print_status_key_created (int letter, PKT_public_key *pk, const char *handle)
147 {
148   byte array[MAX_FINGERPRINT_LEN], *s;
149   char *buf, *p;
150   size_t i, n;
151   
152   if (!handle)
153     handle = "";
154
155   buf = xmalloc (MAX_FINGERPRINT_LEN*2+31 + strlen (handle) + 1);
156
157   p = buf;
158   if (letter || pk)
159     {
160       *p++ = letter;
161       *p++ = ' ';
162       fingerprint_from_pk (pk, array, &n);
163       s = array;
164       for (i=0; i < n ; i++, s++, p += 2)
165         sprintf (p, "%02X", *s);
166     }
167   if (*handle)
168     {
169       *p++ = ' ';
170       for (i=0; handle[i] && i < 100; i++)
171         *p++ = isspace ((unsigned int)handle[i])? '_':handle[i];
172     }
173   *p = 0;
174   write_status_text ((letter || pk)?STATUS_KEY_CREATED:STATUS_KEY_NOT_CREATED,
175                      buf);
176   xfree (buf);
177 }
178
179 static void
180 print_status_key_not_created (const char *handle)
181 {
182   print_status_key_created (0, NULL, handle);
183 }
184
185
186
187 static void
188 write_uid( KBNODE root, const char *s )
189 {
190     PACKET *pkt = xmalloc_clear(sizeof *pkt );
191     size_t n = strlen(s);
192
193     pkt->pkttype = PKT_USER_ID;
194     pkt->pkt.user_id = xmalloc_clear( sizeof *pkt->pkt.user_id + n - 1 );
195     pkt->pkt.user_id->len = n;
196     pkt->pkt.user_id->ref = 1;
197     strcpy(pkt->pkt.user_id->name, s);
198     add_kbnode( root, new_kbnode( pkt ) );
199 }
200
201 static void
202 do_add_key_flags (PKT_signature *sig, unsigned int use)
203 {
204     byte buf[1];
205
206     buf[0] = 0;
207
208     /* The spec says that all primary keys MUST be able to certify. */
209     if(sig->sig_class!=0x18)
210       buf[0] |= 0x01;
211
212     if (use & PUBKEY_USAGE_SIG)
213       buf[0] |= 0x02;
214     if (use & PUBKEY_USAGE_ENC)
215         buf[0] |= 0x04 | 0x08;
216     if (use & PUBKEY_USAGE_AUTH)
217         buf[0] |= 0x20;
218
219     if (!buf[0]) 
220         return;
221
222     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, 1);
223 }
224
225
226 int
227 keygen_add_key_expire (PKT_signature *sig, void *opaque)
228 {
229   PKT_public_key *pk = opaque;
230   byte buf[8];
231   u32  u;
232   
233   if (pk->expiredate)
234     {
235       if (pk->expiredate > pk->timestamp)
236         u = pk->expiredate - pk->timestamp;
237       else
238         u = 1;
239       
240       buf[0] = (u >> 24) & 0xff;
241       buf[1] = (u >> 16) & 0xff;
242       buf[2] = (u >>    8) & 0xff;
243       buf[3] = u & 0xff;
244       build_sig_subpkt (sig, SIGSUBPKT_KEY_EXPIRE, buf, 4);
245     }
246   else
247     {
248       /* Make sure we don't leave a key expiration subpacket lying
249          around */
250       delete_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE);
251     }
252
253   return 0;
254 }
255
256
257 static int
258 keygen_add_key_flags_and_expire (PKT_signature *sig, void *opaque)
259 {
260   struct opaque_data_usage_and_pk *oduap = opaque;
261   
262   do_add_key_flags (sig, oduap->usage);
263   return keygen_add_key_expire (sig, oduap->pk);
264 }
265
266
267 static int
268 set_one_pref (int val, int type, const char *item, byte *buf, int *nbuf)
269 {
270     int i;
271
272     for (i=0; i < *nbuf; i++ )
273       if (buf[i] == val)
274         {
275           log_info (_("preference `%s' duplicated\n"), item);
276           return -1;
277         }
278
279     if (*nbuf >= MAX_PREFS)
280       {
281         if(type==1)
282           log_info(_("too many cipher preferences\n"));
283         else if(type==2)
284           log_info(_("too many digest preferences\n"));
285         else if(type==3)
286           log_info(_("too many compression preferences\n"));
287         else
288           BUG();
289
290         return -1;
291       }
292
293     buf[(*nbuf)++] = val;
294     return 0;
295 }
296
297 /*
298  * Parse the supplied string and use it to set the standard
299  * preferences.  The string may be in a form like the one printed by
300  * "pref" (something like: "S10 S3 H3 H2 Z2 Z1") or the actual
301  * cipher/hash/compress names.  Use NULL to set the default
302  * preferences.  Returns: 0 = okay
303  */
304 int
305 keygen_set_std_prefs (const char *string,int personal)
306 {
307     byte sym[MAX_PREFS], hash[MAX_PREFS], zip[MAX_PREFS];
308     int nsym=0, nhash=0, nzip=0, val, rc=0;
309     int mdc=1, modify=0; /* mdc defaults on, modify defaults off. */
310     char dummy_string[20*4+1]; /* Enough for 20 items. */
311
312     if (!string || !ascii_strcasecmp (string, "default"))
313       {
314         if (opt.def_preference_list)
315           string=opt.def_preference_list;
316         else
317           {
318             int any_compress = 0;
319             dummy_string[0]='\0';
320
321             /* The rationale why we use the order AES256,192,128 is
322                for compatibility reasons with PGP.  If gpg would
323                define AES128 first, we would get the somewhat
324                confusing situation:
325
326                  gpg -r pgpkey -r gpgkey  ---gives--> AES256
327                  gpg -r gpgkey -r pgpkey  ---gives--> AES
328                  
329                Note that by using --personal-cipher-preferences it is
330                possible to prefer AES128.
331             */
332
333             /* Make sure we do not add more than 15 items here, as we
334                could overflow the size of dummy_string.  We currently
335                have at most 12. */
336             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES256) )
337               strcat(dummy_string,"S9 ");
338             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES192) )
339               strcat(dummy_string,"S8 ");
340             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES) )
341               strcat(dummy_string,"S7 ");
342             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_CAST5) )
343               strcat(dummy_string,"S3 ");
344             strcat(dummy_string,"S2 "); /* 3DES */
345             /* If we have it, IDEA goes *after* 3DES so it won't be
346                used unless we're encrypting along with a V3 key.
347                Ideally, we would only put the S1 preference in if the
348                key was RSA and <=2048 bits, as that is what won't
349                break PGP2, but that is difficult with the current
350                code, and not really worth checking as a non-RSA <=2048
351                bit key wouldn't be usable by PGP2 anyway. -dms */
352             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_IDEA) )
353               strcat(dummy_string,"S1 ");
354
355
356             /* The default hash algo order is:
357                  SHA-256, SHA-1, SHA-384, SHA-512, SHA-224.
358                Ordering SHA-1 before SHA-384 might be viewed as a bit
359                strange; it is done because we expect that soon enough
360                SHA-3 will be available and at that point there should
361                be no more need for SHA-384 etc.  Anyway this order is
362                just a default and can easily be changed by a config
363                option.  */
364             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA256))
365               strcat (dummy_string, "H8 ");
366
367             strcat (dummy_string, "H2 "); /* SHA-1 */
368
369             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA384))
370               strcat (dummy_string, "H9 ");
371
372             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA512))
373               strcat (dummy_string, "H10 ");
374
375             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA224))
376               strcat (dummy_string, "H11 ");
377
378             if(!check_compress_algo(COMPRESS_ALGO_ZLIB))
379               {
380                 strcat(dummy_string,"Z2 ");
381                 any_compress = 1;
382               }
383
384             if(!check_compress_algo(COMPRESS_ALGO_BZIP2))
385               {
386                 strcat(dummy_string,"Z3 ");
387                 any_compress = 1;
388               }
389
390             if(!check_compress_algo(COMPRESS_ALGO_ZIP))
391               {
392                 strcat(dummy_string,"Z1 ");
393                 any_compress = 1;
394               }
395             
396             /* In case we have no compress algo at all, declare that
397                we prefer no compresssion.  */
398             if (!any_compress)
399               strcat(dummy_string,"Z0 ");
400
401             /* Remove the trailing space.  */
402             if (*dummy_string && dummy_string[strlen (dummy_string)-1] == ' ')
403               dummy_string[strlen (dummy_string)-1] = 0;
404
405             string=dummy_string;
406           }
407       }
408     else if (!ascii_strcasecmp (string, "none"))
409         string = "";
410
411     if(strlen(string))
412       {
413         char *tok,*prefstring;
414
415         prefstring=xstrdup(string); /* need a writable string! */
416
417         while((tok=strsep(&prefstring," ,")))
418           {
419             if((val=string_to_cipher_algo (tok)))
420               {
421                 if(set_one_pref(val,1,tok,sym,&nsym))
422                   rc=-1;
423               }
424             else if((val=string_to_digest_algo (tok)))
425               {
426                 if(set_one_pref(val,2,tok,hash,&nhash))
427                   rc=-1;
428               }
429             else if((val=string_to_compress_algo(tok))>-1)
430               {
431                 if(set_one_pref(val,3,tok,zip,&nzip))
432                   rc=-1;
433               }
434             else if (ascii_strcasecmp(tok,"mdc")==0)
435               mdc=1;
436             else if (ascii_strcasecmp(tok,"no-mdc")==0)
437               mdc=0;
438             else if (ascii_strcasecmp(tok,"ks-modify")==0)
439               modify=1;
440             else if (ascii_strcasecmp(tok,"no-ks-modify")==0)
441               modify=0;
442             else
443               {
444                 log_info (_("invalid item `%s' in preference string\n"),tok);
445
446                 /* Complain if IDEA is not available. */
447                 if(ascii_strcasecmp(tok,"s1")==0
448                    || ascii_strcasecmp(tok,"idea")==0)
449                   idea_cipher_warn(1);
450
451                 rc=-1;
452               }
453           }
454
455         xfree(prefstring);
456       }
457
458     if(!rc)
459       {
460         if(personal)
461           {
462             if(personal==PREFTYPE_SYM)
463               {
464                 xfree(opt.personal_cipher_prefs);
465
466                 if(nsym==0)
467                   opt.personal_cipher_prefs=NULL;
468                 else
469                   {
470                     int i;
471
472                     opt.personal_cipher_prefs=
473                       xmalloc(sizeof(prefitem_t *)*(nsym+1));
474
475                     for (i=0; i<nsym; i++)
476                       {
477                         opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
478                         opt.personal_cipher_prefs[i].value = sym[i];
479                       }
480
481                     opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
482                     opt.personal_cipher_prefs[i].value = 0;
483                   }
484               }
485             else if(personal==PREFTYPE_HASH)
486               {
487                 xfree(opt.personal_digest_prefs);
488
489                 if(nhash==0)
490                   opt.personal_digest_prefs=NULL;
491                 else
492                   {
493                     int i;
494
495                     opt.personal_digest_prefs=
496                       xmalloc(sizeof(prefitem_t *)*(nhash+1));
497
498                     for (i=0; i<nhash; i++)
499                       {
500                         opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
501                         opt.personal_digest_prefs[i].value = hash[i];
502                       }
503
504                     opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
505                     opt.personal_digest_prefs[i].value = 0;
506                   }
507               }
508             else if(personal==PREFTYPE_ZIP)
509               {
510                 xfree(opt.personal_compress_prefs);
511
512                 if(nzip==0)
513                   opt.personal_compress_prefs=NULL;
514                 else
515                   {
516                     int i;
517
518                     opt.personal_compress_prefs=
519                       xmalloc(sizeof(prefitem_t *)*(nzip+1));
520
521                     for (i=0; i<nzip; i++)
522                       {
523                         opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
524                         opt.personal_compress_prefs[i].value = zip[i];
525                       }
526
527                     opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
528                     opt.personal_compress_prefs[i].value = 0;
529                   }
530               }
531           }
532         else
533           {
534             memcpy (sym_prefs,  sym,  (nsym_prefs=nsym));
535             memcpy (hash_prefs, hash, (nhash_prefs=nhash));
536             memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
537             mdc_available = mdc;
538             ks_modify = modify;
539             prefs_initialized = 1;
540           }
541       }
542
543     return rc;
544 }
545
546 /* Return a fake user ID containing the preferences.  Caller must
547    free. */
548 PKT_user_id *
549 keygen_get_std_prefs(void)
550 {
551   int i,j=0;
552   PKT_user_id *uid=xmalloc_clear(sizeof(PKT_user_id));
553
554   if(!prefs_initialized)
555     keygen_set_std_prefs(NULL,0);
556
557   uid->ref=1;
558
559   uid->prefs=xmalloc((sizeof(prefitem_t *)*
560                       (nsym_prefs+nhash_prefs+nzip_prefs+1)));
561
562   for(i=0;i<nsym_prefs;i++,j++)
563     {
564       uid->prefs[j].type=PREFTYPE_SYM;
565       uid->prefs[j].value=sym_prefs[i];
566     }
567
568   for(i=0;i<nhash_prefs;i++,j++)
569     {
570       uid->prefs[j].type=PREFTYPE_HASH;
571       uid->prefs[j].value=hash_prefs[i];
572     }
573
574   for(i=0;i<nzip_prefs;i++,j++)
575     {
576       uid->prefs[j].type=PREFTYPE_ZIP;
577       uid->prefs[j].value=zip_prefs[i];
578     }
579
580   uid->prefs[j].type=PREFTYPE_NONE;
581   uid->prefs[j].value=0;
582
583   uid->flags.mdc=mdc_available;
584   uid->flags.ks_modify=ks_modify;
585
586   return uid;
587 }
588
589 static void
590 add_feature_mdc (PKT_signature *sig,int enabled)
591 {
592     const byte *s;
593     size_t n;
594     int i;
595     char *buf;
596
597     s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n );
598     /* Already set or cleared */
599     if (s && n &&
600         ((enabled && (s[0] & 0x01)) || (!enabled && !(s[0] & 0x01))))
601       return;
602
603     if (!s || !n) { /* create a new one */
604         n = 1;
605         buf = xmalloc_clear (n);
606     }
607     else {
608         buf = xmalloc (n);
609         memcpy (buf, s, n);
610     }
611
612     if(enabled)
613       buf[0] |= 0x01; /* MDC feature */
614     else
615       buf[0] &= ~0x01;
616
617     /* Are there any bits set? */
618     for(i=0;i<n;i++)
619       if(buf[i]!=0)
620         break;
621
622     if(i==n)
623       delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
624     else
625       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
626
627     xfree (buf);
628 }
629
630 static void
631 add_keyserver_modify (PKT_signature *sig,int enabled)
632 {
633   const byte *s;
634   size_t n;
635   int i;
636   char *buf;
637
638   /* The keyserver modify flag is a negative flag (i.e. no-modify) */
639   enabled=!enabled;
640
641   s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n );
642   /* Already set or cleared */
643   if (s && n &&
644       ((enabled && (s[0] & 0x80)) || (!enabled && !(s[0] & 0x80))))
645     return;
646
647   if (!s || !n) { /* create a new one */
648     n = 1;
649     buf = xmalloc_clear (n);
650   }
651   else {
652     buf = xmalloc (n);
653     memcpy (buf, s, n);
654   }
655
656   if(enabled)
657     buf[0] |= 0x80; /* no-modify flag */
658   else
659     buf[0] &= ~0x80;
660
661   /* Are there any bits set? */
662   for(i=0;i<n;i++)
663     if(buf[i]!=0)
664       break;
665
666   if(i==n)
667     delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
668   else
669     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
670
671   xfree (buf);
672 }
673
674
675 int
676 keygen_upd_std_prefs (PKT_signature *sig, void *opaque)
677 {
678   (void)opaque;
679   
680   if (!prefs_initialized)
681     keygen_set_std_prefs (NULL, 0);
682   
683   if (nsym_prefs) 
684     build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
685   else
686     {
687       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
688       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
689     }
690   
691   if (nhash_prefs)
692     build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
693   else
694     {
695       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
696       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
697     }
698
699   if (nzip_prefs)
700     build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
701   else
702     {
703       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
704       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
705     }
706   
707   /* Make sure that the MDC feature flag is set if needed.  */
708   add_feature_mdc (sig,mdc_available);
709   add_keyserver_modify (sig,ks_modify);
710   keygen_add_keyserver_url(sig,NULL);
711
712   return 0;
713 }
714
715
716 /****************
717  * Add preference to the self signature packet.
718  * This is only called for packets with version > 3.
719  */
720 int
721 keygen_add_std_prefs (PKT_signature *sig, void *opaque)
722 {
723   PKT_public_key *pk = opaque;
724   
725   do_add_key_flags (sig, pk->pubkey_usage);
726   keygen_add_key_expire (sig, opaque );
727   keygen_upd_std_prefs (sig, opaque);
728   keygen_add_keyserver_url (sig,NULL);
729   
730   return 0;
731 }
732
733 int
734 keygen_add_keyserver_url(PKT_signature *sig, void *opaque)
735 {
736   const char *url=opaque;
737
738   if(!url)
739     url=opt.def_keyserver_url;
740
741   if(url)
742     build_sig_subpkt(sig,SIGSUBPKT_PREF_KS,url,strlen(url));
743   else
744     delete_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS);
745
746   return 0;
747 }
748
749 int
750 keygen_add_notations(PKT_signature *sig,void *opaque)
751 {
752   struct notation *notation;
753
754   /* We always start clean */
755   delete_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION);
756   delete_sig_subpkt(sig->unhashed,SIGSUBPKT_NOTATION);
757   sig->flags.notation=0;
758
759   for(notation=opaque;notation;notation=notation->next)
760     if(!notation->flags.ignore)
761       {
762         unsigned char *buf;
763         unsigned int n1,n2;
764
765         n1=strlen(notation->name);
766         if(notation->altvalue)
767           n2=strlen(notation->altvalue);
768         else if(notation->bdat)
769           n2=notation->blen;
770         else
771           n2=strlen(notation->value);
772
773         buf = xmalloc( 8 + n1 + n2 );
774
775         /* human readable or not */
776         buf[0] = notation->bdat?0:0x80;
777         buf[1] = buf[2] = buf[3] = 0;
778         buf[4] = n1 >> 8;
779         buf[5] = n1;
780         buf[6] = n2 >> 8;
781         buf[7] = n2;
782         memcpy(buf+8, notation->name, n1 );
783         if(notation->altvalue)
784           memcpy(buf+8+n1, notation->altvalue, n2 );
785         else if(notation->bdat)
786           memcpy(buf+8+n1, notation->bdat, n2 );
787         else
788           memcpy(buf+8+n1, notation->value, n2 );
789         build_sig_subpkt( sig, SIGSUBPKT_NOTATION |
790                           (notation->flags.critical?SIGSUBPKT_FLAG_CRITICAL:0),
791                           buf, 8+n1+n2 );
792         xfree(buf);
793       }
794
795   return 0;
796 }
797
798 int
799 keygen_add_revkey (PKT_signature *sig, void *opaque)
800 {
801   struct revocation_key *revkey = opaque;
802   byte buf[2+MAX_FINGERPRINT_LEN];
803
804   buf[0] = revkey->class;
805   buf[1] = revkey->algid;
806   memcpy (&buf[2], revkey->fpr, MAX_FINGERPRINT_LEN);
807
808   build_sig_subpkt (sig, SIGSUBPKT_REV_KEY, buf, 2+MAX_FINGERPRINT_LEN);
809
810   /* All sigs with revocation keys set are nonrevocable.  */
811   sig->flags.revocable = 0;
812   buf[0] = 0;
813   build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
814
815   parse_revkeys (sig);
816
817   return 0;
818 }
819
820
821
822 /* Create a back-signature.  If TIMESTAMP is not NULL, use it for the
823    signature creation time.  */
824 gpg_error_t
825 make_backsig (PKT_signature *sig, PKT_public_key *pk,
826               PKT_public_key *sub_pk, PKT_public_key *sub_psk,
827               u32 timestamp)
828 {
829   gpg_error_t err;
830   PKT_signature *backsig;
831
832   cache_public_key (sub_pk);
833
834   err = make_keysig_packet (&backsig, pk, NULL, sub_pk, sub_psk, 0x19,
835                             0, 0, timestamp, 0, NULL, NULL);
836   if (err)
837     log_error ("make_keysig_packet failed for backsig: %s\n", g10_errstr(err));
838   else
839     {
840       /* Get it into a binary packed form. */
841       IOBUF backsig_out = iobuf_temp();
842       PACKET backsig_pkt;
843  
844       init_packet (&backsig_pkt);
845       backsig_pkt.pkttype = PKT_SIGNATURE;
846       backsig_pkt.pkt.signature = backsig;
847       err = build_packet (backsig_out, &backsig_pkt);
848       free_packet (&backsig_pkt);
849       if (err)
850         log_error ("build_packet failed for backsig: %s\n", g10_errstr(err));
851       else
852         {
853           size_t pktlen = 0;
854           byte *buf = iobuf_get_temp_buffer (backsig_out);
855  
856           /* Remove the packet header. */
857           if(buf[0]&0x40)
858             {
859               if (buf[1] < 192)
860                 {
861                   pktlen = buf[1];
862                   buf += 2; 
863                 } 
864               else if(buf[1] < 224)
865                 {
866                   pktlen = (buf[1]-192)*256;
867                   pktlen += buf[2]+192;
868                   buf += 3;
869                 }
870               else if (buf[1] == 255)
871                 {
872                   pktlen  = buf[2] << 24;
873                   pktlen |= buf[3] << 16;
874                   pktlen |= buf[4] << 8;
875                   pktlen |= buf[5];
876                   buf += 6;
877                 }
878               else
879                 BUG ();
880             }
881           else
882             {
883               int mark = 1;
884  
885               switch (buf[0]&3)
886                 {
887                 case 3:
888                   BUG ();
889                   break;
890  
891                 case 2:
892                   pktlen  = buf[mark++] << 24;
893                   pktlen |= buf[mark++] << 16;
894  
895                 case 1:
896                   pktlen |= buf[mark++] << 8;
897  
898                 case 0:
899                   pktlen |= buf[mark++];
900                 }
901  
902               buf += mark;
903             }
904  
905           /* Now make the binary blob into a subpacket.  */
906           build_sig_subpkt (sig, SIGSUBPKT_SIGNATURE, buf, pktlen);
907
908           iobuf_close (backsig_out);
909         }
910     }
911   
912   return err;
913 }
914
915
916 /* Write a direct key signature to the first key in ROOT using the key
917    PSK.  REVKEY is describes the direct key signature and TIMESTAMP is
918    the timestamp to set on the signature.  */
919 static gpg_error_t
920 write_direct_sig (KBNODE root, PKT_public_key *psk,
921                   struct revocation_key *revkey, u32 timestamp)
922 {
923   gpg_error_t err;
924   PACKET *pkt;
925   PKT_signature *sig;
926   KBNODE node;
927   PKT_public_key *pk;
928
929   if (opt.verbose)
930     log_info (_("writing direct signature\n"));
931
932   /* Get the pk packet from the pub_tree. */
933   node = find_kbnode (root, PKT_PUBLIC_KEY);
934   if (!node)
935     BUG ();
936   pk = node->pkt->pkt.public_key;
937
938   /* We have to cache the key, so that the verification of the
939      signature creation is able to retrieve the public key.  */
940   cache_public_key (pk);
941
942   /* Make the signature.  */
943   err = make_keysig_packet (&sig, pk, NULL,NULL, psk, 0x1F,
944                             0, 0, timestamp, 0,
945                             keygen_add_revkey, revkey);
946   if (err)
947     {
948       log_error ("make_keysig_packet failed: %s\n", g10_errstr (err) );
949       return err;
950     }
951   
952   pkt = xmalloc_clear (sizeof *pkt);
953   pkt->pkttype = PKT_SIGNATURE;
954   pkt->pkt.signature = sig;
955   add_kbnode (root, new_kbnode (pkt));
956   return err;
957 }
958
959
960
961 /* Write a self-signature to the first user id in ROOT using the key
962    PSK.  USE and TIMESTAMP give the extra data we need for the
963    signature.  */
964 static gpg_error_t
965 write_selfsigs (KBNODE root, PKT_public_key *psk,
966                 unsigned int use, u32 timestamp)
967 {
968   gpg_error_t err;
969   PACKET *pkt;
970   PKT_signature *sig;
971   PKT_user_id *uid;
972   KBNODE node;
973   PKT_public_key *pk;
974
975   if (opt.verbose)
976     log_info (_("writing self signature\n"));
977
978   /* Get the uid packet from the list. */
979   node = find_kbnode (root, PKT_USER_ID);
980   if (!node)
981     BUG(); /* No user id packet in tree.  */
982   uid = node->pkt->pkt.user_id;
983
984   /* Get the pk packet from the pub_tree. */
985   node = find_kbnode (root, PKT_PUBLIC_KEY);
986   if (!node)
987     BUG();
988   pk = node->pkt->pkt.public_key;
989
990   /* The usage has not yet been set - do it now. */
991   pk->pubkey_usage = use;
992  
993   /* We have to cache the key, so that the verification of the
994      signature creation is able to retrieve the public key.  */
995   cache_public_key (pk);
996
997   /* Make the signature.  */
998   err = make_keysig_packet (&sig, pk, uid, NULL, psk, 0x13,
999                             0, 0, timestamp, 0,
1000                             keygen_add_std_prefs, pk);
1001   if (err) 
1002     {
1003       log_error ("make_keysig_packet failed: %s\n", g10_errstr (err));
1004       return err;
1005     }
1006
1007   pkt = xmalloc_clear (sizeof *pkt);
1008   pkt->pkttype = PKT_SIGNATURE;
1009   pkt->pkt.signature = sig;
1010   add_kbnode (root, new_kbnode (pkt));
1011
1012   return err;
1013 }
1014
1015
1016 /* Write the key binding signature.  If TIMESTAMP is not NULL use the
1017    signature creation time.  PRI_PSK is the key use for signing.
1018    SUB_PSK is a key used to create a back-signature; that one is only
1019    used if USE has the PUBKEY_USAGE_SIG capability.  */
1020 static int
1021 write_keybinding (KBNODE root, PKT_public_key *pri_psk, PKT_public_key *sub_psk,
1022                   unsigned int use, u32 timestamp)
1023 {
1024   gpg_error_t err;
1025   PACKET *pkt;
1026   PKT_signature *sig;
1027   KBNODE node;
1028   PKT_public_key *pri_pk, *sub_pk;
1029   struct opaque_data_usage_and_pk oduap;
1030
1031   if (opt.verbose)
1032     log_info(_("writing key binding signature\n"));
1033
1034   /* Get the primary pk packet from the tree.  */
1035   node = find_kbnode (root, PKT_PUBLIC_KEY);
1036   if (!node)
1037     BUG();
1038   pri_pk = node->pkt->pkt.public_key;
1039
1040   /* We have to cache the key, so that the verification of the
1041    * signature creation is able to retrieve the public key.  */
1042   cache_public_key (pri_pk);
1043  
1044   /* Find the last subkey. */
1045   sub_pk = NULL;
1046   for (node = root; node; node = node->next ) 
1047     {
1048       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1049         sub_pk = node->pkt->pkt.public_key;
1050     }
1051   if (!sub_pk)
1052     BUG();
1053
1054   /* Make the signature.  */
1055   oduap.usage = use;
1056   oduap.pk = sub_pk;
1057   err = make_keysig_packet (&sig, pri_pk, NULL, sub_pk, pri_psk, 0x18, 
1058                             0, 0, timestamp, 0,
1059                             keygen_add_key_flags_and_expire, &oduap);
1060   if (err) 
1061     {
1062       log_error ("make_keysig_packet failed: %s\n", g10_errstr (err));
1063       return err;
1064     }
1065
1066   /* Make a backsig.  */
1067   if (use & PUBKEY_USAGE_SIG)
1068     {
1069       err = make_backsig (sig, pri_pk, sub_pk, sub_psk, timestamp);
1070       if (err)
1071         return err;
1072     }
1073   
1074   pkt = xmalloc_clear ( sizeof *pkt );
1075   pkt->pkttype = PKT_SIGNATURE;
1076   pkt->pkt.signature = sig;
1077   add_kbnode (root, new_kbnode (pkt) );
1078   return err;
1079 }
1080
1081
1082
1083 static int
1084 key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
1085                const char *topname, const char *elems)
1086 {
1087   gcry_sexp_t list, l2;
1088   const char *s;
1089   int i, idx;
1090   int rc = 0;
1091
1092   list = gcry_sexp_find_token (sexp, topname, 0);
1093   if (!list)
1094     return gpg_error (GPG_ERR_INV_OBJ);
1095   l2 = gcry_sexp_cadr (list);
1096   gcry_sexp_release (list);
1097   list = l2;
1098   if (!list)
1099     return gpg_error (GPG_ERR_NO_OBJ);
1100
1101   for (idx=0,s=elems; *s; s++, idx++)
1102     {
1103       l2 = gcry_sexp_find_token (list, s, 1);
1104       if (!l2)
1105         {
1106           rc = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
1107           goto leave;
1108         }
1109       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1110       gcry_sexp_release (l2);
1111       if (!array[idx]) 
1112         {
1113           rc = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
1114           goto leave;
1115         }
1116     }
1117   gcry_sexp_release (list);
1118
1119  leave:
1120   if (rc)
1121     {
1122       for (i=0; i<idx; i++)
1123         {
1124           xfree (array[i]);
1125           array[i] = NULL;
1126         }
1127       gcry_sexp_release (list);
1128     }
1129   return rc;
1130 }
1131
1132
1133
1134 /* Common code for the key generation fucntion gen_xxx.  */
1135 static int
1136 common_gen (const char *keyparms, int algo, const char *algoelem,
1137             kbnode_t pub_root, u32 timestamp, u32 expireval, int is_subkey,
1138             char **cache_nonce_addr)
1139 {
1140   int err;
1141   PACKET *pkt;
1142   PKT_public_key *pk;
1143   gcry_sexp_t s_key;
1144   
1145   err = agent_genkey (NULL, cache_nonce_addr, keyparms, &s_key);
1146   if (err)
1147     {
1148       log_error ("agent_genkey failed: %s\n", gpg_strerror (err) );
1149       return err;
1150     }
1151   
1152   pk = xtrycalloc (1, sizeof *pk);
1153   if (!pk)
1154     {
1155       err = gpg_error_from_syserror ();
1156       gcry_sexp_release (s_key);
1157       return err;
1158     }
1159
1160   pk->timestamp = timestamp;
1161   pk->version = 4;
1162   if (expireval) 
1163     pk->expiredate = pk->timestamp + expireval;
1164   pk->pubkey_algo = algo;
1165
1166   err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
1167   if (err) 
1168     {
1169       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
1170       gcry_sexp_release (s_key);
1171       free_public_key (pk);
1172       return err;
1173     }
1174   gcry_sexp_release (s_key);
1175   
1176   pkt = xtrycalloc (1, sizeof *pkt);
1177   if (!pkt)
1178     {
1179       err = gpg_error_from_syserror ();
1180       free_public_key (pk);
1181       return err;
1182     }
1183
1184   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1185   pkt->pkt.public_key = pk;
1186   add_kbnode (pub_root, new_kbnode (pkt));
1187
1188   return 0;
1189 }
1190
1191
1192 /*
1193  * Generate an Elgamal key.
1194  */
1195 static int
1196 gen_elg (int algo, unsigned int nbits, KBNODE pub_root,
1197          u32 timestamp, u32 expireval, int is_subkey, char **cache_nonce_addr)
1198 {
1199   int err;
1200   char *keyparms;
1201   char nbitsstr[35];
1202   
1203   assert (is_ELGAMAL (algo));
1204
1205   if (nbits < 512)
1206     {
1207       nbits = 1024;
1208       log_info (_("keysize invalid; using %u bits\n"), nbits );
1209     }
1210
1211   if ((nbits % 32))
1212     {
1213       nbits = ((nbits + 31) / 32) * 32;
1214       log_info (_("keysize rounded up to %u bits\n"), nbits );
1215     }
1216
1217   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1218   keyparms = xtryasprintf ("(genkey(%s(nbits %zu:%s)))",
1219                            algo == GCRY_PK_ELG_E ? "openpgp-elg" :
1220                            algo == GCRY_PK_ELG   ? "elg" : "x-oops" ,
1221                            strlen (nbitsstr), nbitsstr);
1222   if (!keyparms)
1223     err = gpg_error_from_syserror ();
1224   else
1225     {
1226       err = common_gen (keyparms, algo, "pgy", 
1227                         pub_root, timestamp, expireval, is_subkey,
1228                         cache_nonce_addr);
1229       xfree (keyparms);
1230     }
1231
1232   return err;
1233 }
1234
1235
1236 /*
1237  * Generate an DSA key
1238  */
1239 static gpg_error_t
1240 gen_dsa (unsigned int nbits, KBNODE pub_root, 
1241          u32 timestamp, u32 expireval, int is_subkey, char **cache_nonce_addr)
1242 {
1243   int err;
1244   unsigned int qbits;
1245   char *keyparms;
1246   char nbitsstr[35];
1247   char qbitsstr[35];
1248
1249   if ( nbits < 512) 
1250     {
1251       nbits = 1024;
1252       log_info(_("keysize invalid; using %u bits\n"), nbits );
1253     }
1254   else if ( nbits > 3072 )
1255     {
1256       nbits = 3072;
1257       log_info(_("keysize invalid; using %u bits\n"), nbits );
1258     }
1259
1260   if( (nbits % 64) )
1261     {
1262       nbits = ((nbits + 63) / 64) * 64;
1263       log_info(_("keysize rounded up to %u bits\n"), nbits );
1264     }
1265
1266   /* To comply with FIPS rules we round up to the next value unless in
1267      expert mode.  */
1268   if (!opt.expert && nbits > 1024 && (nbits % 1024))
1269     {
1270       nbits = ((nbits + 1023) / 1024) * 1024;
1271       log_info(_("keysize rounded up to %u bits\n"), nbits );
1272     }
1273
1274   /*
1275     Figure out a q size based on the key size.  FIPS 180-3 says:
1276  
1277     L = 1024, N = 160
1278     L = 2048, N = 224
1279     L = 2048, N = 256
1280     L = 3072, N = 256
1281  
1282     2048/256 is an odd pair since there is also a 2048/224 and
1283     3072/256.  Matching sizes is not a very exact science.
1284       
1285     We'll do 256 qbits for nbits over 2047, 224 for nbits over 1024
1286     but less than 2048, and 160 for 1024 (DSA1).
1287   */
1288  
1289   if (nbits > 2047)
1290     qbits = 256;
1291   else if ( nbits > 1024)
1292     qbits = 224;
1293   else
1294     qbits = 160;
1295  
1296   if (qbits != 160 )
1297     log_info (_("WARNING: some OpenPGP programs can't"
1298                 " handle a DSA key with this digest size\n"));
1299
1300   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1301   snprintf (qbitsstr, sizeof qbitsstr, "%u", qbits);
1302   keyparms = xtryasprintf ("(genkey(dsa(nbits %zu:%s)(qbits %zu:%s)))",
1303                            strlen (nbitsstr), nbitsstr,
1304                            strlen (qbitsstr), qbitsstr);
1305   if (!keyparms)
1306     err = gpg_error_from_syserror ();
1307   else
1308     {
1309       err = common_gen (keyparms, PUBKEY_ALGO_DSA, "pqgy", 
1310                         pub_root, timestamp, expireval, is_subkey,
1311                         cache_nonce_addr);
1312       xfree (keyparms);
1313     }
1314
1315   return err;
1316 }
1317
1318
1319 /* 
1320  * Generate an RSA key.
1321  */
1322 static int
1323 gen_rsa (int algo, unsigned int nbits, KBNODE pub_root,
1324          u32 timestamp, u32 expireval, int is_subkey, char **cache_nonce_addr)
1325 {
1326   int err;
1327   char *keyparms;
1328   char nbitsstr[35];
1329
1330   assert (is_RSA(algo));
1331
1332   if (!nbits)
1333     nbits = DEFAULT_STD_KEYSIZE;
1334
1335   if (nbits < 1024) 
1336     {
1337       nbits = 1024;
1338       log_info (_("keysize invalid; using %u bits\n"), nbits );
1339     }
1340   
1341   if ((nbits % 32))
1342     {
1343       nbits = ((nbits + 31) / 32) * 32;
1344       log_info (_("keysize rounded up to %u bits\n"), nbits );
1345     }
1346
1347   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1348   keyparms = xtryasprintf ("(genkey(rsa(nbits %zu:%s)))", 
1349                            strlen (nbitsstr), nbitsstr);
1350   if (!keyparms)
1351     err = gpg_error_from_syserror ();
1352   else
1353     {
1354       err = common_gen (keyparms, algo, "ne", 
1355                         pub_root, timestamp, expireval, is_subkey,
1356                         cache_nonce_addr);
1357       xfree (keyparms);
1358     }
1359
1360   return err;
1361 }
1362
1363
1364 /****************
1365  * check valid days:
1366  * return 0 on error or the multiplier
1367  */
1368 static int
1369 check_valid_days( const char *s )
1370 {
1371     if( !digitp(s) )
1372         return 0;
1373     for( s++; *s; s++)
1374         if( !digitp(s) )
1375             break;
1376     if( !*s )
1377         return 1;
1378     if( s[1] )
1379         return 0; /* e.g. "2323wc" */
1380     if( *s == 'd' || *s == 'D' )
1381         return 1;
1382     if( *s == 'w' || *s == 'W' )
1383         return 7;
1384     if( *s == 'm' || *s == 'M' )
1385         return 30;
1386     if( *s == 'y' || *s == 'Y' )
1387         return 365;
1388     return 0;
1389 }
1390
1391
1392 static void
1393 print_key_flags(int flags)
1394 {
1395   if(flags&PUBKEY_USAGE_SIG)
1396     tty_printf("%s ",_("Sign"));
1397
1398   if(flags&PUBKEY_USAGE_CERT)
1399     tty_printf("%s ",_("Certify"));
1400
1401   if(flags&PUBKEY_USAGE_ENC)
1402     tty_printf("%s ",_("Encrypt"));
1403
1404   if(flags&PUBKEY_USAGE_AUTH)
1405     tty_printf("%s ",_("Authenticate"));
1406 }
1407
1408
1409 /* Returns the key flags */
1410 static unsigned int
1411 ask_key_flags(int algo,int subkey)
1412 {
1413   /* TRANSLATORS: Please use only plain ASCII characters for the
1414      translation.  If this is not possible use single digits.  The
1415      string needs to 8 bytes long. Here is a description of the
1416      functions:
1417
1418        s = Toggle signing capability
1419        e = Toggle encryption capability
1420        a = Toggle authentication capability
1421        q = Finish
1422   */
1423   const char *togglers=_("SsEeAaQq");
1424   char *answer=NULL;
1425   unsigned int current=0;
1426   unsigned int possible=openpgp_pk_algo_usage(algo);
1427
1428   if ( strlen(togglers) != 8 )
1429     {
1430       tty_printf ("NOTE: Bad translation at %s:%d. "
1431                   "Please report.\n", __FILE__, __LINE__);
1432       togglers = "11223300";
1433     }
1434
1435   /* Only primary keys may certify. */
1436   if(subkey)
1437     possible&=~PUBKEY_USAGE_CERT;
1438
1439   /* Preload the current set with the possible set, minus
1440      authentication, since nobody really uses auth yet. */
1441   current=possible&~PUBKEY_USAGE_AUTH;
1442
1443   for(;;)
1444     {
1445       tty_printf("\n");
1446       tty_printf(_("Possible actions for a %s key: "),
1447                  gcry_pk_algo_name (algo));
1448       print_key_flags(possible);
1449       tty_printf("\n");
1450       tty_printf(_("Current allowed actions: "));
1451       print_key_flags(current);
1452       tty_printf("\n\n");
1453
1454       if(possible&PUBKEY_USAGE_SIG)
1455         tty_printf(_("   (%c) Toggle the sign capability\n"),
1456                    togglers[0]);
1457       if(possible&PUBKEY_USAGE_ENC)
1458         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
1459                    togglers[2]);
1460       if(possible&PUBKEY_USAGE_AUTH)
1461         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
1462                    togglers[4]);
1463
1464       tty_printf(_("   (%c) Finished\n"),togglers[6]);
1465       tty_printf("\n");
1466
1467       xfree(answer);
1468       answer = cpr_get("keygen.flags",_("Your selection? "));
1469       cpr_kill_prompt();
1470
1471       if(strlen(answer)>1)
1472         tty_printf(_("Invalid selection.\n"));
1473       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1474         break;
1475       else if((*answer==togglers[0] || *answer==togglers[1])
1476               && possible&PUBKEY_USAGE_SIG)
1477         {
1478           if(current&PUBKEY_USAGE_SIG)
1479             current&=~PUBKEY_USAGE_SIG;
1480           else
1481             current|=PUBKEY_USAGE_SIG;
1482         }
1483       else if((*answer==togglers[2] || *answer==togglers[3])
1484               && possible&PUBKEY_USAGE_ENC)
1485         {
1486           if(current&PUBKEY_USAGE_ENC)
1487             current&=~PUBKEY_USAGE_ENC;
1488           else
1489             current|=PUBKEY_USAGE_ENC;
1490         }
1491       else if((*answer==togglers[4] || *answer==togglers[5])
1492               && possible&PUBKEY_USAGE_AUTH)
1493         {
1494           if(current&PUBKEY_USAGE_AUTH)
1495             current&=~PUBKEY_USAGE_AUTH;
1496           else
1497             current|=PUBKEY_USAGE_AUTH;
1498         }
1499       else
1500         tty_printf(_("Invalid selection.\n"));
1501     }
1502
1503   xfree(answer);
1504
1505   return current;
1506 }
1507
1508
1509 /* Ask for an algorithm.  The function returns the algorithm id to
1510  * create. If ADDMODE is false the function won't show an option to
1511  * create the primary and subkey combined and won't set R_USAGE
1512  * either.  If a combined algorithm has been selected, the subkey
1513  * algorithm is stored at R_SUBKEY_ALGO.  */
1514 static int
1515 ask_algo (int addmode, int *r_subkey_algo, unsigned int *r_usage)
1516 {
1517   char *answer;
1518   int algo;
1519   int dummy_algo;
1520
1521   if (!r_subkey_algo)
1522     r_subkey_algo = &dummy_algo;
1523   
1524   tty_printf (_("Please select what kind of key you want:\n"));
1525
1526   if (!addmode)
1527     tty_printf (_("   (%d) RSA and RSA (default)\n"), 1 );
1528   if (!addmode)
1529     tty_printf (_("   (%d) DSA and Elgamal\n"), 2 );
1530
1531   tty_printf (_("   (%d) DSA (sign only)\n"), 3 );
1532   tty_printf (_("   (%d) RSA (sign only)\n"), 4 );
1533
1534   if (addmode)
1535     {
1536       tty_printf (_("   (%d) Elgamal (encrypt only)\n"), 5 );
1537       tty_printf (_("   (%d) RSA (encrypt only)\n"), 6 );
1538     }
1539   if (opt.expert)
1540     {
1541       tty_printf (_("   (%d) DSA (set your own capabilities)\n"), 7 );
1542       tty_printf (_("   (%d) RSA (set your own capabilities)\n"), 8 );
1543     }
1544   
1545   for(;;)
1546     {
1547       *r_usage = 0;
1548       *r_subkey_algo = 0;
1549       answer = cpr_get ("keygen.algo", _("Your selection? "));
1550       cpr_kill_prompt ();
1551       algo = *answer? atoi (answer) : 1;
1552       xfree(answer);
1553       if (algo == 1 && !addmode)
1554         {
1555           algo = PUBKEY_ALGO_RSA;
1556           *r_subkey_algo = PUBKEY_ALGO_RSA;
1557           break;
1558         }
1559       else if (algo == 2 && !addmode)
1560         {
1561           algo = PUBKEY_ALGO_DSA;
1562           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
1563           break;
1564         }
1565       else if (algo == 3)
1566         {
1567           algo = PUBKEY_ALGO_DSA;
1568           *r_usage = PUBKEY_USAGE_SIG;
1569           break;
1570         }
1571       else if (algo == 4)
1572         {
1573           algo = PUBKEY_ALGO_RSA;
1574           *r_usage = PUBKEY_USAGE_SIG;
1575           break;
1576         }
1577       else if (algo == 5 && addmode)
1578         {
1579           algo = PUBKEY_ALGO_ELGAMAL_E;
1580           *r_usage = PUBKEY_USAGE_ENC;
1581           break;
1582         }
1583       else if (algo == 6 && addmode)
1584         {
1585           algo = PUBKEY_ALGO_RSA;
1586           *r_usage = PUBKEY_USAGE_ENC;
1587           break;
1588         }
1589       else if (algo == 7 && opt.expert)
1590         {
1591           algo = PUBKEY_ALGO_DSA;
1592           *r_usage = ask_key_flags (algo, addmode);
1593           break;
1594         }
1595       else if (algo == 8 && opt.expert)
1596         {
1597           algo = PUBKEY_ALGO_RSA;
1598           *r_usage = ask_key_flags (algo, addmode);
1599           break;
1600         }
1601       else
1602         tty_printf (_("Invalid selection.\n"));
1603     }
1604   
1605   return algo;
1606 }
1607
1608
1609 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
1610    is not 0, the function asks for the size of the encryption
1611    subkey. */
1612 static unsigned
1613 ask_keysize (int algo, unsigned int primary_keysize)
1614 {
1615   unsigned int nbits, min, def = DEFAULT_STD_KEYSIZE, max=4096;
1616   int for_subkey = !!primary_keysize;
1617   int autocomp = 0;
1618
1619   if(opt.expert)
1620     min=512;
1621   else
1622     min=1024;
1623
1624   if (primary_keysize && !opt.expert)
1625     {
1626       /* Deduce the subkey size from the primary key size.  */
1627       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
1628         nbits = 3072; /* For performance reasons we don't support more
1629                          than 3072 bit DSA.  However we won't see this
1630                          case anyway because DSA can't be used as an
1631                          encryption subkey ;-). */
1632       else
1633         nbits = primary_keysize;
1634       autocomp = 1;
1635       goto leave;
1636     }
1637
1638   switch(algo)
1639     {
1640     case PUBKEY_ALGO_DSA:
1641       def=2048;
1642       max=3072;
1643       break;
1644
1645     case PUBKEY_ALGO_RSA:
1646       min=1024;
1647       break;
1648     }
1649
1650   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
1651              gcry_pk_algo_name (algo), min, max);
1652
1653   for(;;)
1654     {
1655       char *prompt, *answer;
1656
1657       if (for_subkey)
1658         prompt = xasprintf (_("What keysize do you want "
1659                               "for the subkey? (%u) "), def);
1660       else
1661         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
1662       answer = cpr_get ("keygen.size", prompt);
1663       cpr_kill_prompt ();
1664       nbits = *answer? atoi (answer): def;
1665       xfree(prompt);
1666       xfree(answer);
1667       
1668       if(nbits<min || nbits>max)
1669         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
1670                    gcry_pk_algo_name (algo), min, max);
1671       else
1672         break;
1673     }
1674
1675   tty_printf(_("Requested keysize is %u bits\n"), nbits );
1676
1677  leave:
1678   if( algo == PUBKEY_ALGO_DSA && (nbits % 64) )
1679     {
1680       nbits = ((nbits + 63) / 64) * 64;
1681       if (!autocomp)
1682         tty_printf(_("rounded up to %u bits\n"), nbits );
1683     }
1684   else if( (nbits % 32) )
1685     {
1686       nbits = ((nbits + 31) / 32) * 32;
1687       if (!autocomp)
1688         tty_printf(_("rounded up to %u bits\n"), nbits );
1689     }
1690
1691   return nbits;
1692 }
1693
1694
1695 /****************
1696  * Parse an expire string and return its value in seconds.
1697  * Returns (u32)-1 on error.
1698  * This isn't perfect since scan_isodatestr returns unix time, and
1699  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
1700  * Because of this, we only permit setting expirations up to 2106, but
1701  * OpenPGP could theoretically allow up to 2242.  I think we'll all
1702  * just cope for the next few years until we get a 64-bit time_t or
1703  * similar.
1704  */
1705 u32
1706 parse_expire_string( const char *string )
1707 {
1708   int mult;
1709   u32 seconds;
1710   u32 abs_date = 0;
1711   u32 curtime = make_timestamp ();
1712   time_t tt;
1713   
1714   if (!*string)
1715     seconds = 0;
1716   else if (!strncmp (string, "seconds=", 8))
1717     seconds = atoi (string+8);
1718   else if ((abs_date = scan_isodatestr(string))
1719            && (abs_date+86400/2) > curtime)
1720     seconds = (abs_date+86400/2) - curtime;
1721   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
1722     seconds = (u32)tt - curtime;
1723   else if ((mult = check_valid_days (string)))
1724     seconds = atoi (string) * 86400L * mult;
1725   else
1726     seconds = (u32)(-1);
1727   
1728   return seconds;
1729 }
1730
1731 /* Parsean Creation-Date string which is either "1986-04-26" or
1732    "19860426T042640".  Returns 0 on error. */
1733 static u32
1734 parse_creation_string (const char *string)
1735 {
1736   u32 seconds;
1737   
1738   if (!*string)
1739     seconds = 0;
1740   else if ( !strncmp (string, "seconds=", 8) )
1741     seconds = atoi (string+8);
1742   else if ( !(seconds = scan_isodatestr (string)))
1743     {
1744       time_t tmp = isotime2epoch (string);
1745       seconds = (tmp == (time_t)(-1))? 0 : tmp;
1746     }
1747   return seconds;
1748 }
1749
1750
1751 /* object == 0 for a key, and 1 for a sig */
1752 u32
1753 ask_expire_interval(int object,const char *def_expire)
1754 {
1755     u32 interval;
1756     char *answer;
1757
1758     switch(object)
1759       {
1760       case 0:
1761         if(def_expire)
1762           BUG();
1763         tty_printf(_("Please specify how long the key should be valid.\n"
1764                      "         0 = key does not expire\n"
1765                      "      <n>  = key expires in n days\n"
1766                      "      <n>w = key expires in n weeks\n"
1767                      "      <n>m = key expires in n months\n"
1768                      "      <n>y = key expires in n years\n"));
1769         break;
1770
1771       case 1:
1772         if(!def_expire)
1773           BUG();
1774         tty_printf(_("Please specify how long the signature should be valid.\n"
1775                      "         0 = signature does not expire\n"
1776                      "      <n>  = signature expires in n days\n"
1777                      "      <n>w = signature expires in n weeks\n"
1778                      "      <n>m = signature expires in n months\n"
1779                      "      <n>y = signature expires in n years\n"));
1780         break;
1781
1782       default:
1783         BUG();
1784       }
1785
1786     /* Note: The elgamal subkey for DSA has no expiration date because
1787      * it must be signed with the DSA key and this one has the expiration
1788      * date */
1789
1790     answer = NULL;
1791     for(;;)
1792       {
1793         u32 curtime=make_timestamp();
1794
1795         xfree(answer);
1796         if(object==0)
1797           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1798         else
1799           {
1800             char *prompt;
1801
1802 #define PROMPTSTRING _("Signature is valid for? (%s) ")
1803             /* This will actually end up larger than necessary because
1804                of the 2 bytes for '%s' */
1805             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
1806             sprintf(prompt,PROMPTSTRING,def_expire);
1807 #undef PROMPTSTRING
1808
1809             answer = cpr_get("siggen.valid",prompt);
1810             xfree(prompt);
1811
1812             if(*answer=='\0')
1813               answer=xstrdup(def_expire);
1814           }
1815         cpr_kill_prompt();
1816         trim_spaces(answer);
1817         interval = parse_expire_string( answer );
1818         if( interval == (u32)-1 )
1819           {
1820             tty_printf(_("invalid value\n"));
1821             continue;
1822           }
1823
1824         if( !interval )
1825           {
1826             tty_printf((object==0)
1827                        ? _("Key does not expire at all\n")
1828                        : _("Signature does not expire at all\n"));
1829           }
1830         else
1831           {
1832             tty_printf(object==0
1833                        ? _("Key expires at %s\n")
1834                        : _("Signature expires at %s\n"),
1835                        asctimestamp((ulong)(curtime + interval) ) );
1836 #if SIZEOF_TIME_T <= 4
1837             if ( (time_t)((ulong)(curtime+interval)) < 0 )
1838               tty_printf (_("Your system can't display dates beyond 2038.\n"
1839                             "However, it will be correctly handled up to"
1840                             " 2106.\n"));
1841             else
1842 #endif /*SIZEOF_TIME_T*/
1843               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
1844                 {
1845                   tty_printf (_("invalid value\n"));
1846                   continue;
1847                 }
1848           }
1849
1850         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1851                                                    _("Is this correct? (y/N) ")) )
1852           break;
1853       }
1854
1855     xfree(answer);
1856     return interval;
1857 }
1858
1859 u32
1860 ask_expiredate()
1861 {
1862     u32 x = ask_expire_interval(0,NULL);
1863     return x? make_timestamp() + x : 0;
1864 }
1865
1866
1867
1868 static PKT_user_id *
1869 uid_from_string (const char *string)
1870 {
1871   size_t n;
1872   PKT_user_id *uid;
1873
1874   n = strlen (string);
1875   uid = xmalloc_clear (sizeof *uid + n);
1876   uid->len = n;
1877   strcpy (uid->name, string);
1878   uid->ref = 1;
1879   return uid;
1880 }
1881
1882
1883 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
1884    printed for use during a new key creation.  If KEYBLOCK is not NULL
1885    the function prevents the creation of an already existing user
1886    ID.  */
1887 static char *
1888 ask_user_id (int mode, KBNODE keyblock)
1889 {
1890     char *answer;
1891     char *aname, *acomment, *amail, *uid;
1892
1893     if ( !mode )
1894       {
1895         /* TRANSLATORS: This is the new string telling the user what
1896            gpg is now going to do (i.e. ask for the parts of the user
1897            ID).  Note that if you do not tyranslated this string, a
1898            different string will be used used, which might still have
1899            a correct transaltion.  */
1900         const char *s1 =
1901           N_("\n"
1902              "GnuPG needs to construct a user ID to identify your key.\n"
1903              "\n");
1904         const char *s2 = _(s1);
1905
1906         if (!strcmp (s1, s2))
1907           {
1908             /* There is no translation for the string thus we to use
1909                the old info text.  gettext has no way to tell whether
1910                a translation is actually available, thus we need to
1911                to compare again. */
1912             /* TRANSLATORS: This string is in general not anymore used
1913                but you should keep your existing translation.  In case
1914                the new string is not translated this old string will
1915                be used. */
1916             const char *s3 = N_("\n"
1917 "You need a user ID to identify your key; "
1918                                         "the software constructs the user ID\n"
1919 "from the Real Name, Comment and Email Address in this form:\n"
1920 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
1921             const char *s4 = _(s3);
1922             if (strcmp (s3, s4))
1923               s2 = s3; /* A translation exists - use it. */
1924           }
1925         tty_printf ("%s", s2) ;
1926       }
1927     uid = aname = acomment = amail = NULL;
1928     for(;;) {
1929         char *p;
1930         int fail=0;
1931
1932         if( !aname ) {
1933             for(;;) {
1934                 xfree(aname);
1935                 aname = cpr_get("keygen.name",_("Real name: "));
1936                 trim_spaces(aname);
1937                 cpr_kill_prompt();
1938
1939                 if( opt.allow_freeform_uid )
1940                     break;
1941
1942                 if( strpbrk( aname, "<>" ) )
1943                     tty_printf(_("Invalid character in name\n"));
1944                 else if( digitp(aname) )
1945                     tty_printf(_("Name may not start with a digit\n"));
1946                 else if( strlen(aname) < 5 )
1947                     tty_printf(_("Name must be at least 5 characters long\n"));
1948                 else
1949                     break;
1950             }
1951         }
1952         if( !amail ) {
1953             for(;;) {
1954                 xfree(amail);
1955                 amail = cpr_get("keygen.email",_("Email address: "));
1956                 trim_spaces(amail);
1957                 cpr_kill_prompt();
1958                 if( !*amail || opt.allow_freeform_uid )
1959                     break;   /* no email address is okay */
1960                 else if ( !is_valid_mailbox (amail) )
1961                     tty_printf(_("Not a valid email address\n"));
1962                 else
1963                     break;
1964             }
1965         }
1966         if( !acomment ) {
1967             for(;;) {
1968                 xfree(acomment);
1969                 acomment = cpr_get("keygen.comment",_("Comment: "));
1970                 trim_spaces(acomment);
1971                 cpr_kill_prompt();
1972                 if( !*acomment )
1973                     break;   /* no comment is okay */
1974                 else if( strpbrk( acomment, "()" ) )
1975                     tty_printf(_("Invalid character in comment\n"));
1976                 else
1977                     break;
1978             }
1979         }
1980
1981
1982         xfree(uid);
1983         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1984         p = stpcpy(p, aname );
1985         if( *acomment )
1986             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1987         if( *amail )
1988             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1989
1990         /* Append a warning if the RNG is switched into fake mode.  */
1991         if ( random_is_faked ()  )
1992           strcpy(p, " (insecure!)" );
1993
1994         /* print a note in case that UTF8 mapping has to be done */
1995         for(p=uid; *p; p++ ) {
1996             if( *p & 0x80 ) {
1997                 tty_printf(_("You are using the `%s' character set.\n"),
1998                            get_native_charset() );
1999                 break;
2000             }
2001         }
2002
2003         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2004
2005         if( !*amail && !opt.allow_freeform_uid
2006             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2007             fail = 1;
2008             tty_printf(_("Please don't put the email address "
2009                          "into the real name or the comment\n") );
2010         }
2011
2012         if (!fail && keyblock)
2013           {
2014             PKT_user_id *uidpkt = uid_from_string (uid);
2015             KBNODE node;
2016
2017             for (node=keyblock; node && !fail; node=node->next)
2018               if (!is_deleted_kbnode (node)
2019                   && node->pkt->pkttype == PKT_USER_ID
2020                   && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2021                 fail = 1;
2022             if (fail)
2023               tty_printf (_("Such a user ID already exists on this key!\n"));
2024             free_user_id (uidpkt);
2025           }
2026
2027         for(;;) {
2028             /* TRANSLATORS: These are the allowed answers in
2029                lower and uppercase.  Below you will find the matching
2030                string which should be translated accordingly and the
2031                letter changed to match the one in the answer string.
2032                
2033                  n = Change name
2034                  c = Change comment
2035                  e = Change email
2036                  o = Okay (ready, continue)
2037                  q = Quit
2038              */
2039             const char *ansstr = _("NnCcEeOoQq");
2040
2041             if( strlen(ansstr) != 10 )
2042                 BUG();
2043             if( cpr_enabled() ) {
2044                 answer = xstrdup (ansstr + (fail?8:6));
2045                 answer[1] = 0;
2046             }
2047             else {
2048                 answer = cpr_get("keygen.userid.cmd", fail?
2049                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2050                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2051                 cpr_kill_prompt();
2052             }
2053             if( strlen(answer) > 1 )
2054                 ;
2055             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2056                 xfree(aname); aname = NULL;
2057                 break;
2058             }
2059             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2060                 xfree(acomment); acomment = NULL;
2061                 break;
2062             }
2063             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2064                 xfree(amail); amail = NULL;
2065                 break;
2066             }
2067             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2068                 if( fail ) {
2069                     tty_printf(_("Please correct the error first\n"));
2070                 }
2071                 else {
2072                     xfree(aname); aname = NULL;
2073                     xfree(acomment); acomment = NULL;
2074                     xfree(amail); amail = NULL;
2075                     break;
2076                 }
2077             }
2078             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2079                 xfree(aname); aname = NULL;
2080                 xfree(acomment); acomment = NULL;
2081                 xfree(amail); amail = NULL;
2082                 xfree(uid); uid = NULL;
2083                 break;
2084             }
2085             xfree(answer);
2086         }
2087         xfree(answer);
2088         if( !amail && !acomment && !amail )
2089             break;
2090         xfree(uid); uid = NULL;
2091     }
2092     if( uid ) {
2093         char *p = native_to_utf8( uid );
2094         xfree( uid );
2095         uid = p;
2096     }
2097     return uid;
2098 }
2099
2100
2101 /*  MODE  0 - standard
2102           1 - Ask for passphrase of the card backup key.  */
2103 static DEK *
2104 do_ask_passphrase (STRING2KEY **ret_s2k, int mode, int *r_canceled)
2105 {
2106     DEK *dek = NULL;
2107     STRING2KEY *s2k;
2108     const char *errtext = NULL;
2109     const char *custdesc = NULL;
2110
2111     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
2112
2113     if (mode == 1)
2114       custdesc = _("Please enter a passphrase to protect the off-card "
2115                    "backup of the new encryption key.");
2116
2117     s2k = xmalloc_secure( sizeof *s2k );
2118     for(;;) {
2119         s2k->mode = opt.s2k_mode;
2120         s2k->hash_algo = S2K_DIGEST_ALGO;
2121         dek = passphrase_to_dek_ext (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2122                                      errtext, custdesc, NULL, r_canceled);
2123         if (!dek && *r_canceled) {
2124             xfree(dek); dek = NULL;
2125             xfree(s2k); s2k = NULL;
2126             break;
2127         }
2128         else if( !dek ) {
2129             errtext = N_("passphrase not correctly repeated; try again");
2130             tty_printf(_("%s.\n"), _(errtext));
2131         }
2132         else if( !dek->keylen ) {
2133             xfree(dek); dek = NULL;
2134             xfree(s2k); s2k = NULL;
2135             tty_printf(_(
2136             "You don't want a passphrase - this is probably a *bad* idea!\n"
2137             "I will do it anyway.  You can change your passphrase at any time,\n"
2138             "using this program with the option \"--edit-key\".\n\n"));
2139             break;
2140         }
2141         else
2142             break; /* okay */
2143     }
2144     *ret_s2k = s2k;
2145     return dek;
2146 }
2147
2148
2149 /* Basic key generation.  Here we divert to the actual generation
2150    routines based on the requested algorithm.  */
2151 static int
2152 do_create (int algo, unsigned int nbits, KBNODE pub_root,
2153            u32 timestamp, u32 expiredate, int is_subkey,
2154            char **cache_nonce_addr)
2155 {
2156   gpg_error_t err;
2157
2158   /* Fixme: The entropy collecting message should be moved to a
2159      libgcrypt progress handler.  */
2160   if (!opt.batch)
2161     tty_printf (_(
2162 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2163 "some other action (type on the keyboard, move the mouse, utilize the\n"
2164 "disks) during the prime generation; this gives the random number\n"
2165 "generator a better chance to gain enough entropy.\n") );
2166
2167   if (algo == PUBKEY_ALGO_ELGAMAL_E)
2168     err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2169                    cache_nonce_addr);
2170   else if (algo == PUBKEY_ALGO_DSA)
2171     err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
2172                    cache_nonce_addr);
2173   else if (algo == PUBKEY_ALGO_RSA)
2174     err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2175                    cache_nonce_addr);
2176   else
2177     BUG();
2178
2179   return err;
2180 }
2181
2182
2183 /* Generate a new user id packet or return NULL if canceled.  If
2184    KEYBLOCK is not NULL the function prevents the creation of an
2185    already existing user ID.  */
2186 PKT_user_id *
2187 generate_user_id (KBNODE keyblock)
2188 {
2189   char *p;
2190   
2191   p = ask_user_id (1, keyblock);
2192   if (!p)
2193     return NULL;  /* Canceled. */
2194   return uid_from_string (p);
2195 }
2196
2197
2198 static void
2199 release_parameter_list( struct para_data_s *r )
2200 {
2201     struct para_data_s *r2;
2202
2203     for( ; r ; r = r2 ) {
2204         r2 = r->next;
2205         if( r->key == pPASSPHRASE_DEK )
2206             xfree( r->u.dek );
2207         else if( r->key == pPASSPHRASE_S2K )
2208             xfree( r->u.s2k );
2209
2210         xfree(r);
2211     }
2212 }
2213
2214 static struct para_data_s *
2215 get_parameter( struct para_data_s *para, enum para_name key )
2216 {
2217     struct para_data_s *r;
2218
2219     for( r = para; r && r->key != key; r = r->next )
2220         ;
2221     return r;
2222 }
2223
2224 static const char *
2225 get_parameter_value( struct para_data_s *para, enum para_name key )
2226 {
2227     struct para_data_s *r = get_parameter( para, key );
2228     return (r && *r->u.value)? r->u.value : NULL;
2229 }
2230
2231 static int
2232 get_parameter_algo( struct para_data_s *para, enum para_name key, 
2233                     int *r_default)
2234 {
2235   int i;
2236   struct para_data_s *r = get_parameter( para, key );
2237
2238   if (r_default)
2239     *r_default = 0;
2240
2241   if (!r)
2242     return -1;
2243
2244   if (!ascii_strcasecmp (r->u.value, "default"))
2245     {
2246       /* Note: If you change this default algo, remember to change it
2247          also in gpg.c:gpgconf_list.  */
2248       i = DEFAULT_STD_ALGO;
2249       if (r_default)
2250         *r_default = 1;
2251     }
2252   else if (digitp (r->u.value))
2253     i = atoi( r->u.value );
2254   else if (!strcmp (r->u.value, "ELG-E")
2255            || !strcmp (r->u.value, "ELG"))
2256     i = GCRY_PK_ELG_E;
2257   else
2258     i = gcry_pk_map_name (r->u.value);
2259
2260   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2261     i = 0; /* we don't want to allow generation of these algorithms */
2262   return i;
2263 }
2264
2265 /* 
2266  * Parse the usage parameter and set the keyflags.  Returns -1 on
2267  * error, 0 for no usage given or 1 for usage available.
2268  */
2269 static int
2270 parse_parameter_usage (const char *fname,
2271                        struct para_data_s *para, enum para_name key)
2272 {
2273     struct para_data_s *r = get_parameter( para, key );
2274     char *p, *pn;
2275     unsigned int use;
2276
2277     if( !r )
2278         return 0; /* none (this is an optional parameter)*/
2279     
2280     use = 0;
2281     pn = r->u.value;
2282     while ( (p = strsep (&pn, " \t,")) ) {
2283         if ( !*p)
2284             ;
2285         else if ( !ascii_strcasecmp (p, "sign") )
2286             use |= PUBKEY_USAGE_SIG;
2287         else if ( !ascii_strcasecmp (p, "encrypt") )
2288             use |= PUBKEY_USAGE_ENC;
2289         else if ( !ascii_strcasecmp (p, "auth") )
2290             use |= PUBKEY_USAGE_AUTH;
2291         else {
2292             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2293             return -1; /* error */
2294         }
2295     }
2296     r->u.usage = use;
2297     return 1;
2298 }
2299
2300 static int
2301 parse_revocation_key (const char *fname,
2302                       struct para_data_s *para, enum para_name key)
2303 {
2304   struct para_data_s *r = get_parameter( para, key );
2305   struct revocation_key revkey;
2306   char *pn;
2307   int i;
2308
2309   if( !r )
2310     return 0; /* none (this is an optional parameter) */
2311
2312   pn = r->u.value;
2313
2314   revkey.class=0x80;
2315   revkey.algid=atoi(pn);
2316   if(!revkey.algid)
2317     goto fail;
2318
2319   /* Skip to the fpr */
2320   while(*pn && *pn!=':')
2321     pn++;
2322
2323   if(*pn!=':')
2324     goto fail;
2325
2326   pn++;
2327
2328   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2329     {
2330       int c=hextobyte(pn);
2331       if(c==-1)
2332         goto fail;
2333
2334       revkey.fpr[i]=c;
2335     }
2336
2337   /* skip to the tag */
2338   while(*pn && *pn!='s' && *pn!='S')
2339     pn++;
2340
2341   if(ascii_strcasecmp(pn,"sensitive")==0)
2342     revkey.class|=0x40;
2343
2344   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2345
2346   return 0;
2347
2348   fail:
2349   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2350   return -1; /* error */
2351 }
2352
2353
2354 static u32
2355 get_parameter_u32( struct para_data_s *para, enum para_name key )
2356 {
2357   struct para_data_s *r = get_parameter( para, key );
2358
2359   if( !r )
2360     return 0;
2361   if( r->key == pKEYCREATIONDATE )
2362     return r->u.creation;
2363   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2364     return r->u.expire;
2365   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2366     return r->u.usage;
2367   
2368   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2369 }
2370
2371 static unsigned int
2372 get_parameter_uint( struct para_data_s *para, enum para_name key )
2373 {
2374     return get_parameter_u32( para, key );
2375 }
2376
2377 static struct revocation_key *
2378 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2379 {
2380     struct para_data_s *r = get_parameter( para, key );
2381     return r? &r->u.revkey : NULL;
2382 }
2383
2384 static int
2385 proc_parameter_file( struct para_data_s *para, const char *fname,
2386                      struct output_control_s *outctrl, int card )
2387 {
2388   struct para_data_s *r;
2389   const char *s1, *s2, *s3;
2390   size_t n;
2391   char *p;
2392   int is_default = 0;
2393   int have_user_id = 0;
2394   int err, algo;
2395
2396   /* Check that we have all required parameters. */
2397   r = get_parameter( para, pKEYTYPE );
2398   if(r)
2399     {
2400       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
2401       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2402         {
2403           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2404           return -1;
2405         }
2406     }
2407   else
2408     {
2409       log_error ("%s: no Key-Type specified\n",fname);
2410       return -1;
2411     }
2412
2413   err = parse_parameter_usage (fname, para, pKEYUSAGE);
2414   if (!err)
2415     {
2416       /* Default to algo capabilities if key-usage is not provided and
2417          no default algorithm has been requested.  */
2418       r = xmalloc_clear(sizeof(*r));
2419       r->key = pKEYUSAGE;
2420       r->u.usage = (is_default
2421                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
2422                     : openpgp_pk_algo_usage(algo));
2423       r->next = para;
2424       para = r;
2425     }
2426   else if (err == -1)
2427     return -1;
2428   else
2429     {
2430       r = get_parameter (para, pKEYUSAGE);
2431       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2432         {
2433           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
2434                      fname, r->lnr, algo);
2435           return -1;
2436         }
2437     }
2438
2439   is_default = 0;
2440   r = get_parameter( para, pSUBKEYTYPE );
2441   if(r)
2442     {
2443       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
2444       if (openpgp_pk_test_algo (algo))
2445         {
2446           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2447           return -1;
2448         }
2449
2450       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2451       if (!err)
2452         {
2453           /* Default to algo capabilities if subkey-usage is not
2454              provided */
2455           r = xmalloc_clear (sizeof(*r));
2456           r->key = pSUBKEYUSAGE;
2457           r->u.usage = (is_default
2458                         ? PUBKEY_USAGE_ENC
2459                         : openpgp_pk_algo_usage (algo));
2460           r->next = para;
2461           para = r;
2462         }
2463       else if (err == -1)
2464         return -1;
2465       else
2466         {
2467           r = get_parameter (para, pSUBKEYUSAGE);
2468           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2469             {
2470               log_error ("%s:%d: specified Subkey-Usage not allowed"
2471                          " for algo %d\n", fname, r->lnr, algo);
2472               return -1;
2473             }
2474         }
2475     }
2476
2477
2478   if( get_parameter_value( para, pUSERID ) )
2479     have_user_id=1;
2480   else
2481     {
2482       /* create the formatted user ID */
2483       s1 = get_parameter_value( para, pNAMEREAL );
2484       s2 = get_parameter_value( para, pNAMECOMMENT );
2485       s3 = get_parameter_value( para, pNAMEEMAIL );
2486       if( s1 || s2 || s3 )
2487         {
2488           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2489           r = xmalloc_clear( sizeof *r + n + 20 );
2490           r->key = pUSERID;
2491           p = r->u.value;
2492           if( s1 )
2493             p = stpcpy(p, s1 );
2494           if( s2 )
2495             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2496           if( s3 )
2497             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2498           r->next = para;
2499           para = r;
2500           have_user_id=1;
2501         }
2502     }
2503
2504   if(!have_user_id)
2505     {
2506       log_error("%s: no User-ID specified\n",fname);
2507       return -1;
2508     }
2509
2510   /* Set preferences, if any. */
2511   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2512
2513   /* Set keyserver, if any. */
2514   s1=get_parameter_value( para, pKEYSERVER );
2515   if(s1)
2516     {
2517       struct keyserver_spec *spec;
2518
2519       spec=parse_keyserver_uri(s1,1,NULL,0);
2520       if(spec)
2521         {
2522           free_keyserver_spec(spec);
2523           opt.def_keyserver_url=s1;
2524         }
2525       else
2526         {
2527           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
2528           return -1;
2529         }
2530     }
2531
2532   /* Set revoker, if any. */
2533   if (parse_revocation_key (fname, para, pREVOKER))
2534     return -1;
2535
2536   /* Make DEK and S2K from the Passphrase. */
2537   if (outctrl->ask_passphrase)
2538     {
2539       /* %ask-passphrase is active - ignore pPASSPRASE and ask.  This
2540          feature is required so that GUIs are able to do a key
2541          creation but have gpg-agent ask for the passphrase.  */
2542       int canceled = 0;
2543       STRING2KEY *s2k;
2544       DEK *dek;
2545
2546       dek = do_ask_passphrase (&s2k, 0, &canceled);
2547       if (dek)
2548         {
2549           r = xmalloc_clear( sizeof *r );
2550           r->key = pPASSPHRASE_DEK;
2551           r->u.dek = dek;
2552           r->next = para;
2553           para = r;
2554           r = xmalloc_clear( sizeof *r );
2555           r->key = pPASSPHRASE_S2K;
2556           r->u.s2k = s2k;
2557           r->next = para;
2558           para = r;
2559         }
2560
2561       if (canceled) 
2562         {
2563           log_error ("%s:%d: key generation canceled\n", fname, r->lnr );
2564           return -1;
2565         }
2566     }
2567   else
2568     {
2569       r = get_parameter( para, pPASSPHRASE );
2570       if ( r && *r->u.value )
2571         {
2572           /* We have a plain text passphrase - create a DEK from it.
2573            * It is a little bit ridiculous to keep it in secure memory
2574            * but because we do this always, why not here.  */
2575           STRING2KEY *s2k;
2576           DEK *dek;
2577           
2578           s2k = xmalloc_secure ( sizeof *s2k );
2579           s2k->mode = opt.s2k_mode;
2580           s2k->hash_algo = S2K_DIGEST_ALGO;
2581           set_next_passphrase ( r->u.value );
2582           dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2583                                    NULL, NULL);
2584           set_next_passphrase (NULL );
2585           assert (dek);
2586           memset (r->u.value, 0, strlen(r->u.value));
2587           
2588           r = xmalloc_clear (sizeof *r);
2589           r->key = pPASSPHRASE_S2K;
2590           r->u.s2k = s2k;
2591           r->next = para;
2592           para = r;
2593           r = xmalloc_clear (sizeof *r);
2594           r->key = pPASSPHRASE_DEK;
2595           r->u.dek = dek;
2596           r->next = para;
2597           para = r;
2598         }
2599     }
2600
2601   /* Make KEYCREATIONDATE from Creation-Date.  */
2602   r = get_parameter (para, pCREATIONDATE);
2603   if (r && *r->u.value)
2604     {
2605       u32 seconds;
2606
2607       seconds = parse_creation_string (r->u.value);
2608       if (!seconds)
2609         {
2610           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
2611           return -1;
2612         }
2613       r->u.creation = seconds;
2614       r->key = pKEYCREATIONDATE;  /* Change that entry. */
2615     }
2616
2617   /* Make KEYEXPIRE from Expire-Date.  */
2618   r = get_parameter( para, pEXPIREDATE );
2619   if( r && *r->u.value )
2620     {
2621       u32 seconds;
2622
2623       seconds = parse_expire_string( r->u.value );
2624       if( seconds == (u32)-1 )
2625         {
2626           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2627           return -1;
2628         }
2629       r->u.expire = seconds;
2630       r->key = pKEYEXPIRE;  /* change hat entry */
2631       /* also set it for the subkey */
2632       r = xmalloc_clear( sizeof *r + 20 );
2633       r->key = pSUBKEYEXPIRE;
2634       r->u.expire = seconds;
2635       r->next = para;
2636       para = r;
2637     }
2638
2639   if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2640     log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2641     return -1;
2642   }
2643
2644   do_generate_keypair( para, outctrl, card );
2645   return 0;
2646 }
2647
2648
2649 /****************
2650  * Kludge to allow non interactive key generation controlled
2651  * by a parameter file.
2652  * Note, that string parameters are expected to be in UTF-8
2653  */
2654 static void
2655 read_parameter_file( const char *fname )
2656 {
2657     static struct { const char *name;
2658                     enum para_name key;
2659     } keywords[] = {
2660         { "Key-Type",       pKEYTYPE},
2661         { "Key-Length",     pKEYLENGTH },
2662         { "Key-Usage",      pKEYUSAGE },
2663         { "Subkey-Type",    pSUBKEYTYPE },
2664         { "Subkey-Length",  pSUBKEYLENGTH },
2665         { "Subkey-Usage",   pSUBKEYUSAGE },
2666         { "Name-Real",      pNAMEREAL },
2667         { "Name-Email",     pNAMEEMAIL },
2668         { "Name-Comment",   pNAMECOMMENT },
2669         { "Expire-Date",    pEXPIREDATE },
2670         { "Creation-Date",  pCREATIONDATE },
2671         { "Passphrase",     pPASSPHRASE },
2672         { "Preferences",    pPREFERENCES },
2673         { "Revoker",        pREVOKER },
2674         { "Handle",         pHANDLE },
2675         { "Keyserver",      pKEYSERVER },
2676         { NULL, 0 }
2677     };
2678     IOBUF fp;
2679     byte *line;
2680     unsigned int maxlen, nline;
2681     char *p;
2682     int lnr;
2683     const char *err = NULL;
2684     struct para_data_s *para, *r;
2685     int i;
2686     struct output_control_s outctrl;
2687
2688     memset( &outctrl, 0, sizeof( outctrl ) );
2689     outctrl.pub.afx = new_armor_context ();
2690     outctrl.sec.afx = new_armor_context ();
2691
2692     if( !fname || !*fname)
2693       fname = "-";
2694
2695     fp = iobuf_open (fname);
2696     if (fp && is_secured_file (iobuf_get_fd (fp)))
2697       {
2698         iobuf_close (fp);
2699         fp = NULL;
2700         gpg_err_set_errno (EPERM);
2701       }
2702     if (!fp) {
2703       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2704       return;
2705     }
2706     iobuf_ioctl (fp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
2707
2708     lnr = 0;
2709     err = NULL;
2710     para = NULL;
2711     maxlen = 1024;
2712     line = NULL;
2713     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2714         char *keyword, *value;
2715
2716         lnr++;
2717         if( !maxlen ) {
2718             err = "line too long";
2719             break;
2720         }
2721         for( p = line; isspace(*(byte*)p); p++ )
2722             ;
2723         if( !*p || *p == '#' )
2724             continue;
2725         keyword = p;
2726         if( *keyword == '%' ) {
2727             for( ; !isspace(*(byte*)p); p++ )
2728                 ;
2729             if( *p )
2730                 *p++ = 0;
2731             for( ; isspace(*(byte*)p); p++ )
2732                 ;
2733             value = p;
2734             trim_trailing_ws( value, strlen(value) );
2735             if( !ascii_strcasecmp( keyword, "%echo" ) )
2736                 log_info("%s\n", value );
2737             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2738                 outctrl.dryrun = 1;
2739             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
2740                 outctrl.ask_passphrase = 1;
2741             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
2742                 outctrl.ask_passphrase = 0;
2743             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2744                 outctrl.lnr = lnr;
2745                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2746                   print_status_key_not_created 
2747                     (get_parameter_value (para, pHANDLE));
2748                 release_parameter_list( para );
2749                 para = NULL;
2750             }
2751             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2752                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2753                     ; /* still the same file - ignore it */
2754                 else {
2755                     xfree( outctrl.pub.newfname );
2756                     outctrl.pub.newfname = xstrdup( value );
2757                     outctrl.use_files = 1;
2758                 }
2759             }
2760             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2761                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2762                     ; /* still the same file - ignore it */
2763                 else {
2764                    xfree( outctrl.sec.newfname );
2765                    outctrl.sec.newfname = xstrdup( value );
2766                    outctrl.use_files = 1;
2767                 }
2768             }
2769             else
2770                 log_info("skipping control `%s' (%s)\n", keyword, value );
2771
2772
2773             continue;
2774         }
2775
2776
2777         if( !(p = strchr( p, ':' )) || p == keyword ) {
2778             err = "missing colon";
2779             break;
2780         }
2781         if( *p )
2782             *p++ = 0;
2783         for( ; isspace(*(byte*)p); p++ )
2784             ;
2785         if( !*p ) {
2786             err = "missing argument";
2787             break;
2788         }
2789         value = p;
2790         trim_trailing_ws( value, strlen(value) );
2791
2792         for(i=0; keywords[i].name; i++ ) {
2793             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2794                 break;
2795         }
2796         if( !keywords[i].name ) {
2797             err = "unknown keyword";
2798             break;
2799         }
2800         if( keywords[i].key != pKEYTYPE && !para ) {
2801             err = "parameter block does not start with \"Key-Type\"";
2802             break;
2803         }
2804
2805         if( keywords[i].key == pKEYTYPE && para ) {
2806             outctrl.lnr = lnr;
2807             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2808               print_status_key_not_created
2809                 (get_parameter_value (para, pHANDLE));
2810             release_parameter_list( para );
2811             para = NULL;
2812         }
2813         else {
2814             for( r = para; r; r = r->next ) {
2815                 if( r->key == keywords[i].key )
2816                     break;
2817             }
2818             if( r ) {
2819                 err = "duplicate keyword";
2820                 break;
2821             }
2822         }
2823         r = xmalloc_clear( sizeof *r + strlen( value ) );
2824         r->lnr = lnr;
2825         r->key = keywords[i].key;
2826         strcpy( r->u.value, value );
2827         r->next = para;
2828         para = r;
2829     }
2830     if( err )
2831         log_error("%s:%d: %s\n", fname, lnr, err );
2832     else if( iobuf_error (fp) ) {
2833         log_error("%s:%d: read error\n", fname, lnr);
2834     }
2835     else if( para ) {
2836         outctrl.lnr = lnr;
2837         if (proc_parameter_file( para, fname, &outctrl, 0 ))
2838           print_status_key_not_created (get_parameter_value (para, pHANDLE));
2839     }
2840
2841     if( outctrl.use_files ) { /* close open streams */
2842         iobuf_close( outctrl.pub.stream );
2843         iobuf_close( outctrl.sec.stream );
2844
2845         /* Must invalidate that ugly cache to actually close it.  */
2846         if (outctrl.pub.fname)
2847           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 
2848                        0, (char*)outctrl.pub.fname);
2849         if (outctrl.sec.fname)
2850           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
2851                        0, (char*)outctrl.sec.fname);
2852
2853         xfree( outctrl.pub.fname );
2854         xfree( outctrl.pub.newfname );
2855         xfree( outctrl.sec.fname );
2856         xfree( outctrl.sec.newfname );
2857     }
2858
2859     release_parameter_list( para );
2860     iobuf_close (fp);
2861     release_armor_context (outctrl.pub.afx);
2862     release_armor_context (outctrl.sec.afx);
2863 }
2864
2865
2866 /*
2867  * Generate a keypair (fname is only used in batch mode) If
2868  * CARD_SERIALNO is not NULL the function will create the keys on an
2869  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
2870  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
2871  * generate in software, imported to the card and a backup file
2872  * written to directory given by this argument .
2873  */
2874 void
2875 generate_keypair (const char *fname, const char *card_serialno, 
2876                   const char *backup_encryption_dir)
2877 {
2878   unsigned int nbits;
2879   char *uid = NULL;
2880   int algo;
2881   unsigned int use;
2882   int both = 0;
2883   u32 expire;
2884   struct para_data_s *para = NULL;
2885   struct para_data_s *r;
2886   struct output_control_s outctrl;
2887   
2888   memset( &outctrl, 0, sizeof( outctrl ) );
2889   
2890   if (opt.batch && card_serialno)
2891     {
2892       /* We don't yet support unattended key generation. */
2893       log_error (_("can't do this in batch mode\n"));
2894       return;
2895     }
2896   
2897   if (opt.batch)
2898     {
2899       read_parameter_file( fname );
2900       return;
2901     }
2902
2903   if (card_serialno)
2904     {
2905 #ifdef ENABLE_CARD_SUPPORT
2906       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2907       r->key = pSERIALNO;
2908       strcpy( r->u.value, card_serialno);
2909       r->next = para;
2910       para = r;
2911        
2912       algo = PUBKEY_ALGO_RSA;
2913        
2914       r = xcalloc (1, sizeof *r + 20 );
2915       r->key = pKEYTYPE;
2916       sprintf( r->u.value, "%d", algo );
2917       r->next = para;
2918       para = r;
2919       r = xcalloc (1, sizeof *r + 20 );
2920       r->key = pKEYUSAGE;
2921       strcpy (r->u.value, "sign");
2922       r->next = para;
2923       para = r;
2924        
2925       r = xcalloc (1, sizeof *r + 20 );
2926       r->key = pSUBKEYTYPE;
2927       sprintf( r->u.value, "%d", algo );
2928       r->next = para;
2929       para = r;
2930       r = xcalloc (1, sizeof *r + 20 );
2931       r->key = pSUBKEYUSAGE;
2932       strcpy (r->u.value, "encrypt");
2933       r->next = para;
2934       para = r;
2935        
2936       r = xcalloc (1, sizeof *r + 20 );
2937       r->key = pAUTHKEYTYPE;
2938       sprintf( r->u.value, "%d", algo );
2939       r->next = para;
2940       para = r;
2941
2942       if (backup_encryption_dir)
2943         {
2944           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
2945           r->key = pBACKUPENCDIR;
2946           strcpy (r->u.value, backup_encryption_dir);
2947           r->next = para;
2948           para = r;
2949         }
2950 #endif /*ENABLE_CARD_SUPPORT*/
2951     }
2952   else
2953     {
2954       int subkey_algo; 
2955
2956       algo = ask_algo (0, &subkey_algo, &use);
2957       if (subkey_algo)
2958         { 
2959           /* Create primary and subkey at once.  */
2960           both = 1;
2961           r = xmalloc_clear( sizeof *r + 20 );
2962           r->key = pKEYTYPE;
2963           sprintf( r->u.value, "%d", algo );
2964           r->next = para;
2965           para = r;
2966           nbits = ask_keysize (algo, 0);
2967           r = xmalloc_clear( sizeof *r + 20 );
2968           r->key = pKEYLENGTH;
2969           sprintf( r->u.value, "%u", nbits);
2970           r->next = para;
2971           para = r;
2972           r = xmalloc_clear( sizeof *r + 20 );
2973           r->key = pKEYUSAGE;
2974           strcpy( r->u.value, "sign" );
2975           r->next = para;
2976           para = r;
2977            
2978           r = xmalloc_clear( sizeof *r + 20 );
2979           r->key = pSUBKEYTYPE;
2980           sprintf( r->u.value, "%d", subkey_algo);
2981           r->next = para;
2982           para = r;
2983           r = xmalloc_clear( sizeof *r + 20 );
2984           r->key = pSUBKEYUSAGE;
2985           strcpy( r->u.value, "encrypt" );
2986           r->next = para;
2987           para = r;
2988         }
2989       else 
2990         {
2991           r = xmalloc_clear( sizeof *r + 20 );
2992           r->key = pKEYTYPE;
2993           sprintf( r->u.value, "%d", algo );
2994           r->next = para;
2995           para = r;
2996            
2997           if (use)
2998             {
2999               r = xmalloc_clear( sizeof *r + 25 );
3000               r->key = pKEYUSAGE;
3001               sprintf( r->u.value, "%s%s%s",
3002                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
3003                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
3004                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
3005               r->next = para;
3006               para = r;
3007             }
3008           nbits = 0;
3009         }
3010
3011       nbits = ask_keysize (both? subkey_algo : algo, nbits);
3012       r = xmalloc_clear( sizeof *r + 20 );
3013       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
3014       sprintf( r->u.value, "%u", nbits);
3015       r->next = para;
3016       para = r;
3017     }
3018    
3019   expire = ask_expire_interval(0,NULL);
3020   r = xmalloc_clear( sizeof *r + 20 );
3021   r->key = pKEYEXPIRE;
3022   r->u.expire = expire;
3023   r->next = para;
3024   para = r;
3025   r = xmalloc_clear( sizeof *r + 20 );
3026   r->key = pSUBKEYEXPIRE;
3027   r->u.expire = expire;
3028   r->next = para;
3029   para = r;
3030
3031   uid = ask_user_id (0, NULL);
3032   if( !uid ) 
3033     {
3034       log_error(_("Key generation canceled.\n"));
3035       release_parameter_list( para );
3036       return;
3037     }
3038   r = xmalloc_clear( sizeof *r + strlen(uid) );
3039   r->key = pUSERID;
3040   strcpy( r->u.value, uid );
3041   r->next = para;
3042   para = r;
3043     
3044   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
3045   release_parameter_list( para );
3046 }
3047
3048
3049 #ifdef ENABLE_CARD_SUPPORT
3050 /* Generate a raw key and return it as a secret key packet.  The
3051    function will ask for the passphrase and return a protected as well
3052    as an unprotected copy of a new secret key packet.  0 is returned
3053    on success and the caller must then free the returned values.  */
3054 static int
3055 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
3056                   PKT_secret_key **r_sk_unprotected,
3057                   PKT_secret_key **r_sk_protected)
3058 {
3059   int rc;
3060   DEK *dek = NULL;
3061   STRING2KEY *s2k = NULL;
3062   PKT_secret_key *sk = NULL;
3063   int i;
3064   size_t nskey, npkey;
3065   gcry_sexp_t s_parms, s_key;
3066   int canceled;
3067
3068   npkey = pubkey_get_npkey (algo);
3069   nskey = pubkey_get_nskey (algo);
3070   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
3071
3072   if (nbits < 512)
3073     {
3074       nbits = 512;
3075       log_info (_("keysize invalid; using %u bits\n"), nbits );
3076     }
3077
3078   if ((nbits % 32)) 
3079     {
3080       nbits = ((nbits + 31) / 32) * 32;
3081       log_info(_("keysize rounded up to %u bits\n"), nbits );
3082     }
3083
3084   dek = do_ask_passphrase (&s2k, 1, &canceled);
3085   if (canceled)
3086     {
3087       rc = gpg_error (GPG_ERR_CANCELED);
3088       goto leave;
3089     }
3090
3091   sk = xmalloc_clear (sizeof *sk);
3092   sk->timestamp = created_at;
3093   sk->version = 4;
3094   sk->pubkey_algo = algo;
3095
3096   if ( !is_RSA (algo) )
3097     {
3098       log_error ("only RSA is supported for offline generated keys\n");
3099       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3100       goto leave;
3101     }
3102   rc = gcry_sexp_build (&s_parms, NULL,
3103                         "(genkey(rsa(nbits %d)))",
3104                         (int)nbits);
3105   if (rc)
3106     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
3107   rc = gcry_pk_genkey (&s_key, s_parms);
3108   gcry_sexp_release (s_parms);
3109   if (rc)
3110     {
3111       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
3112       goto leave;
3113     }
3114   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
3115   gcry_sexp_release (s_key);
3116   if (rc) 
3117     {
3118       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
3119       goto leave;
3120     }
3121   
3122   for (i=npkey; i < nskey; i++)
3123     sk->csum += checksum_mpi (sk->skey[i]);
3124
3125   if (r_sk_unprotected) 
3126     *r_sk_unprotected = copy_secret_key (NULL, sk);
3127
3128   rc = genhelp_protect (dek, s2k, sk);
3129   if (rc)
3130     goto leave;
3131
3132   if (r_sk_protected)
3133     {
3134       *r_sk_protected = sk;
3135       sk = NULL;
3136     }
3137
3138  leave:
3139   if (sk)
3140     free_secret_key (sk);
3141   xfree (dek);
3142   xfree (s2k);
3143   return rc;
3144 }
3145 #endif /* ENABLE_CARD_SUPPORT */
3146
3147 /* Create and delete a dummy packet to start off a list of kbnodes. */
3148 static void
3149 start_tree(KBNODE *tree)
3150 {
3151   PACKET *pkt;
3152
3153   pkt=xmalloc_clear(sizeof(*pkt));
3154   pkt->pkttype=PKT_NONE;
3155   *tree=new_kbnode(pkt);
3156   delete_kbnode(*tree);
3157 }
3158
3159
3160 static void
3161 do_generate_keypair (struct para_data_s *para,
3162                      struct output_control_s *outctrl, int card)
3163 {
3164   gpg_error_t err;
3165   KBNODE pub_root = NULL;
3166   const char *s;
3167   PKT_public_key *pri_psk = NULL;
3168   PKT_public_key *sub_psk = NULL;
3169   struct revocation_key *revkey;
3170   int did_sub = 0;
3171   u32 timestamp;
3172   char *cache_nonce = NULL;
3173
3174   if (outctrl->dryrun)
3175     {
3176       log_info("dry-run mode - key generation skipped\n");
3177       return;
3178     }
3179   
3180   if ( outctrl->use_files ) 
3181     {
3182       if ( outctrl->pub.newfname ) 
3183         {
3184           iobuf_close(outctrl->pub.stream);
3185           outctrl->pub.stream = NULL;
3186           if (outctrl->pub.fname)
3187             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3188                          0, (char*)outctrl->pub.fname);
3189           xfree( outctrl->pub.fname );
3190           outctrl->pub.fname =  outctrl->pub.newfname;
3191           outctrl->pub.newfname = NULL;
3192           
3193           if (is_secured_filename (outctrl->pub.fname) ) 
3194             {
3195               outctrl->pub.stream = NULL;
3196               gpg_err_set_errno (EPERM);
3197             }
3198           else
3199             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
3200           if (!outctrl->pub.stream)
3201             {
3202               log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
3203                         strerror(errno) );
3204               return;
3205             }
3206           if (opt.armor)
3207             {
3208               outctrl->pub.afx->what = 1;
3209               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
3210             }
3211         }
3212       assert( outctrl->pub.stream );
3213       if (opt.verbose)
3214         log_info (_("writing public key to `%s'\n"), outctrl->pub.fname );
3215     }
3216
3217
3218   /* We create the packets as a tree of kbnodes.  Because the
3219      structure we create is known in advance we simply generate a
3220      linked list.  The first packet is a dummy packet which we flag as
3221      deleted.  The very first packet must always be a KEY packet.  */
3222     
3223   start_tree (&pub_root);
3224
3225   timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
3226   if (!timestamp)
3227     timestamp = make_timestamp ();
3228
3229   /* Note that, depending on the backend (i.e. the used scdaemon
3230      version), the card key generation may update TIMESTAMP for each
3231      key.  Thus we need to pass TIMESTAMP to all signing function to
3232      make sure that the binding signature is done using the timestamp
3233      of the corresponding (sub)key and not that of the primary key.
3234      An alternative implementation could tell the signing function the
3235      node of the subkey but that is more work than just to pass the
3236      current timestamp.  */
3237
3238   if (!card)
3239     err = do_create (get_parameter_algo( para, pKEYTYPE, NULL ),
3240                      get_parameter_uint( para, pKEYLENGTH ),
3241                      pub_root,
3242                      timestamp,
3243                      get_parameter_u32( para, pKEYEXPIRE ), 0, &cache_nonce);
3244   else
3245     err = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root,
3246                         &timestamp,
3247                         get_parameter_u32 (para, pKEYEXPIRE), para);
3248
3249   /* Get the pointer to the generated public key packet.  */
3250   if (!err)
3251     {
3252       pri_psk = pub_root->next->pkt->pkt.public_key;
3253       assert (pri_psk);
3254     }
3255
3256   if (!err && (revkey = get_parameter_revkey (para, pREVOKER)))
3257     err = write_direct_sig (pub_root, pri_psk, revkey, timestamp);
3258
3259   if (!err && (s = get_parameter_value (para, pUSERID)))
3260     {
3261       write_uid (pub_root, s );
3262       err = write_selfsigs (pub_root, pri_psk,
3263                             get_parameter_uint (para, pKEYUSAGE), timestamp);
3264     }
3265
3266   /* Write the auth key to the card before the encryption key.  This
3267      is a partial workaround for a PGP bug (as of this writing, all
3268      versions including 8.1), that causes it to try and encrypt to
3269      the most recent subkey regardless of whether that subkey is
3270      actually an encryption type.  In this case, the auth key is an
3271      RSA key so it succeeds. */
3272
3273   if (!err && card && get_parameter (para, pAUTHKEYTYPE))
3274     {
3275       err = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root,
3276                           &timestamp,
3277                           get_parameter_u32 (para, pKEYEXPIRE), para);
3278       if (!err)
3279         err = write_keybinding (pub_root, pri_psk, NULL,
3280                                 PUBKEY_USAGE_AUTH, timestamp);
3281     }
3282
3283   if (!err && get_parameter (para, pSUBKEYTYPE))
3284     {
3285       sub_psk = NULL;
3286       if (!card)
3287         {
3288           err = do_create (get_parameter_algo (para, pSUBKEYTYPE, NULL),
3289                            get_parameter_uint (para, pSUBKEYLENGTH),
3290                            pub_root, 
3291                            timestamp,
3292                            get_parameter_u32 (para, pSUBKEYEXPIRE), 1,
3293                            &cache_nonce);
3294           /* Get the pointer to the generated public subkey packet.  */
3295           if (!err)
3296             {
3297               kbnode_t node;
3298               
3299               for (node = pub_root; node; node = node->next)
3300                 if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3301                   sub_psk = node->pkt->pkt.public_key;
3302               assert (sub_psk);
3303             }
3304         }
3305       else
3306         {
3307           if ((s = get_parameter_value (para, pBACKUPENCDIR)))
3308             {
3309               /* A backup of the encryption key has been requested.
3310                  Generate the key in software and import it then to
3311                  the card.  Write a backup file. */
3312               err = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
3313                                               pub_root,
3314                                               timestamp,
3315                                               get_parameter_u32 (para,
3316                                                                  pKEYEXPIRE),
3317                                               para, s);
3318             }
3319           else
3320             {
3321               err = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root,
3322                                   &timestamp,
3323                                   get_parameter_u32 (para, pKEYEXPIRE), para);
3324             }
3325         }
3326
3327       if (!err)
3328         err = write_keybinding (pub_root, pri_psk, sub_psk,
3329                                 get_parameter_uint (para, pSUBKEYUSAGE),
3330                                 timestamp);
3331       did_sub = 1;
3332     }
3333
3334   if (!err && outctrl->use_files)  /* Direct write to specified files.  */
3335     {
3336       err = write_keyblock (outctrl->pub.stream, pub_root);
3337       if (err)
3338         log_error ("can't write public key: %s\n", g10_errstr (err));
3339     }
3340   else if (!err) /* Write to the standard keyrings.  */
3341     {
3342       KEYDB_HANDLE pub_hd = keydb_new ();
3343
3344       err = keydb_locate_writable (pub_hd, NULL);
3345       if (err) 
3346         log_error (_("no writable public keyring found: %s\n"),
3347                    g10_errstr (err));
3348       
3349       if (!err && opt.verbose)
3350         {
3351           log_info (_("writing public key to `%s'\n"),
3352                     keydb_get_resource_name (pub_hd));
3353         }
3354       
3355       if (!err) 
3356         {
3357           err = keydb_insert_keyblock (pub_hd, pub_root);
3358           if (err)
3359             log_error (_("error writing public keyring `%s': %s\n"),
3360                        keydb_get_resource_name (pub_hd), g10_errstr(err));
3361         }
3362       
3363       keydb_release (pub_hd);
3364       
3365       if (!err)
3366         {
3367           int no_enc_rsa;
3368           PKT_public_key *pk;
3369
3370           no_enc_rsa = ((get_parameter_algo (para, pKEYTYPE, NULL)
3371                          == PUBKEY_ALGO_RSA)
3372                         && get_parameter_uint (para, pKEYUSAGE)
3373                         && !((get_parameter_uint (para, pKEYUSAGE)
3374                               & PUBKEY_USAGE_ENC)) );
3375
3376           pk = find_kbnode (pub_root, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3377
3378           keyid_from_pk (pk, pk->main_keyid);
3379           register_trusted_keyid (pk->main_keyid);
3380
3381           update_ownertrust (pk, ((get_ownertrust (pk) & ~TRUST_MASK)
3382                                   | TRUST_ULTIMATE ));
3383
3384           if (!opt.batch) 
3385             {
3386               tty_printf (_("public and secret key created and signed.\n") );
3387               tty_printf ("\n");
3388               list_keyblock (pub_root, 0, 1, NULL);
3389             }
3390             
3391           
3392           if (!opt.batch
3393               && (get_parameter_algo (para, pKEYTYPE, NULL) == PUBKEY_ALGO_DSA
3394                   || no_enc_rsa )
3395               && !get_parameter (para, pSUBKEYTYPE) )
3396             {
3397               tty_printf(_("Note that this key cannot be used for "
3398                            "encryption.  You may want to use\n"
3399                            "the command \"--edit-key\" to generate a "
3400                            "subkey for this purpose.\n") );
3401             }
3402         }
3403     }
3404
3405   if (err)
3406     {
3407       if (opt.batch)
3408         log_error ("key generation failed: %s\n", g10_errstr(err) );
3409       else
3410         tty_printf (_("Key generation failed: %s\n"), g10_errstr(err) );
3411       write_status_error (card? "card_key_generate":"key_generate", err);
3412       print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
3413     }
3414   else
3415     {
3416       PKT_public_key *pk = find_kbnode (pub_root, 
3417                                         PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3418       print_status_key_created (did_sub? 'B':'P', pk,
3419                                 get_parameter_value (para, pHANDLE));
3420     }
3421   
3422   release_kbnode (pub_root);
3423   xfree (cache_nonce);
3424 }
3425
3426
3427 /* Add a new subkey to an existing key.  Returns 0 if a new key has
3428    been generated and put into the keyblocks.  */
3429 gpg_error_t
3430 generate_subkeypair (KBNODE keyblock)
3431 {
3432   gpg_error_t err = 0;
3433   kbnode_t node;
3434   PKT_public_key *pri_psk = NULL;
3435   PKT_public_key *sub_psk = NULL;
3436   int algo;
3437   unsigned int use;
3438   u32 expire;
3439   unsigned int nbits;
3440   u32 cur_time;
3441
3442   /* Break out the primary key.  */
3443   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
3444   if (!node) 
3445     {
3446       log_error ("Oops; primary key missing in keyblock!\n");
3447       err = gpg_error (GPG_ERR_BUG);
3448       goto leave;
3449     }
3450   pri_psk = node->pkt->pkt.public_key;
3451
3452   cur_time = make_timestamp ();
3453
3454   if (pri_psk->timestamp > cur_time)
3455     {
3456       ulong d = pri_psk->timestamp - cur_time;
3457       log_info ( d==1 ? _("key has been created %lu second "
3458                           "in future (time warp or clock problem)\n")
3459                  : _("key has been created %lu seconds "
3460                      "in future (time warp or clock problem)\n"), d );
3461       if (!opt.ignore_time_conflict)
3462         {
3463           err = gpg_error (GPG_ERR_TIME_CONFLICT);
3464           goto leave;
3465         }
3466     }
3467
3468   if (pri_psk->version < 4) 
3469     {
3470       log_info (_("NOTE: creating subkeys for v3 keys "
3471                   "is not OpenPGP compliant\n"));
3472       err = gpg_error (GPG_ERR_CONFLICT);
3473       goto leave;
3474     }
3475
3476 #warning ask gpg-agent on the availibility of the secret key
3477   /* if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001) */
3478   /*   { */
3479   /*     tty_printf (_("Secret parts of primary key are not available.\n")); */
3480   /*     err = G10ERR_NO_SECKEY; */
3481   /*     goto leave; */
3482   /*   } */
3483
3484
3485   /* /\* Unprotect to get the passphrase.  *\/ */
3486   /* switch (is_secret_key_protected (pri_sk) ) */
3487   /*   { */
3488   /*   case -1: */
3489   /*     err = G10ERR_PUBKEY_ALGO; */
3490   /*     break; */
3491   /*   case 0: */
3492   /*     tty_printf (_("This key is not protected.\n")); */
3493   /*     break; */
3494   /*   case -2: */
3495   /*     tty_printf (_("Secret parts of primary key are stored on-card.\n")); */
3496   /*     ask_pass = 1; */
3497   /*     break; */
3498   /*   default: */
3499   /*     tty_printf (_("Key is protected.\n")); */
3500   /*     err = check_secret_key ( pri_sk, 0 ); */
3501   /*     if (!err) */
3502   /*       passphrase = get_last_passphrase(); */
3503   /*     break; */
3504   /*   } */
3505   /* if (err) */
3506   /*   goto leave; */
3507
3508   algo = ask_algo (1, NULL, &use);
3509   assert (algo);
3510   nbits = ask_keysize (algo, 0);
3511   expire = ask_expire_interval (0, NULL);
3512   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3513                                                _("Really create? (y/N) ")))
3514     {
3515       err = gpg_error (GPG_ERR_CANCELED);
3516       goto leave;
3517     }  
3518
3519   err = do_create (algo, nbits, keyblock, cur_time, expire, 1, NULL);
3520   if (err)
3521     goto leave;
3522
3523   /* Get the pointer to the generated public subkey packet.  */
3524   for (node = keyblock; node; node = node->next)
3525     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3526       sub_psk = node->pkt->pkt.public_key;
3527
3528   /* Write the binding signature.  */
3529   err = write_keybinding (keyblock, pri_psk, sub_psk, use, cur_time);
3530   if (err)
3531     goto leave;
3532
3533   write_status_text (STATUS_KEY_CREATED, "S");
3534
3535  leave:
3536   if (err)
3537     log_error (_("Key generation failed: %s\n"), g10_errstr (err) );
3538   return err;
3539 }
3540
3541
3542 #ifdef ENABLE_CARD_SUPPORT
3543 /* Generate a subkey on a card. */
3544 int
3545 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3546                           int keyno, const char *serialno)
3547 {
3548   gpg_error_t err = 0;
3549   int okay = 0;
3550   kbnode_t node;
3551   PKT_secret_key *pri_sk = NULL, *sub_sk;
3552   int algo;
3553   unsigned int use;
3554   u32 expire;
3555   char *passphrase = NULL;
3556   u32 cur_time;
3557   struct para_data_s *para = NULL;
3558
3559   assert (keyno >= 1 && keyno <= 3);
3560
3561   para = xcalloc (1, sizeof *para + strlen (serialno) );
3562   para->key = pSERIALNO;
3563   strcpy (para->u.value, serialno);
3564
3565   /* Break out the primary secret key */
3566   node = find_kbnode (sec_keyblock, PKT_SECRET_KEY);
3567   if (!node)
3568     {
3569       log_error("Oops; secret key not found anymore!\n");
3570       goto leave;
3571     }
3572
3573   /* Make a copy of the sk to keep the protected one in the keyblock */
3574   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3575
3576   cur_time = make_timestamp();
3577   if (pri_sk->timestamp > cur_time)
3578     {
3579       ulong d = pri_sk->timestamp - cur_time;
3580       log_info (d==1 ? _("key has been created %lu second "
3581                          "in future (time warp or clock problem)\n")
3582                      : _("key has been created %lu seconds "
3583                          "in future (time warp or clock problem)\n"), d );
3584         if (!opt.ignore_time_conflict)
3585           {
3586             err = G10ERR_TIME_CONFLICT;
3587             goto leave;
3588           }
3589     }
3590
3591   if (pri_sk->version < 4)
3592     {
3593       log_info (_("NOTE: creating subkeys for v3 keys "
3594                   "is not OpenPGP compliant\n"));
3595       goto leave;
3596     }
3597
3598   /* Unprotect to get the passphrase. */
3599   switch( is_secret_key_protected (pri_sk) )
3600     {
3601     case -1:
3602       err = G10ERR_PUBKEY_ALGO;
3603       break;
3604     case 0:
3605       tty_printf("This key is not protected.\n");
3606       break;
3607     default:
3608       tty_printf("Key is protected.\n");
3609       err = check_secret_key( pri_sk, 0 );
3610       if (!err)
3611         passphrase = get_last_passphrase();
3612       break;
3613     }
3614   if (err)
3615     goto leave;
3616
3617   algo = PUBKEY_ALGO_RSA;
3618   expire = ask_expire_interval (0,NULL);
3619   if (keyno == 1)
3620     use = PUBKEY_USAGE_SIG;
3621   else if (keyno == 2)
3622     use = PUBKEY_USAGE_ENC;
3623   else
3624     use = PUBKEY_USAGE_AUTH;
3625   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3626                                                _("Really create? (y/N) ")))
3627     goto leave;
3628
3629   if (passphrase)
3630     set_next_passphrase (passphrase);
3631
3632   /* Note, that depending on the backend, the card key generation may
3633      update CUR_TIME.  */
3634   err = gen_card_key (algo, keyno, 0, pub_keyblock, &cur_time, expire, para);
3635   if (!err)
3636     err = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, sub_sk, 
3637                             use, cur_time);
3638   if (!err)
3639     err = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, sub_sk, 
3640                            use, cur_time);
3641   if (!err)
3642     {
3643       okay = 1;
3644       write_status_text (STATUS_KEY_CREATED, "S");
3645     }
3646
3647  leave:
3648   if (err)
3649     log_error (_("Key generation failed: %s\n"), g10_errstr(err) );
3650   xfree (passphrase);
3651   /* Release the copy of the (now unprotected) secret keys. */
3652   if (pri_sk)
3653     free_secret_key (pri_sk);
3654   set_next_passphrase( NULL );
3655   release_parameter_list (para);
3656   return okay;
3657 }
3658 #endif /* !ENABLE_CARD_SUPPORT */
3659
3660
3661 /*
3662  * Write a keyblock to an output stream
3663  */
3664 static int
3665 write_keyblock( IOBUF out, KBNODE node )
3666 {
3667   for( ; node ; node = node->next )
3668     {
3669       if(!is_deleted_kbnode(node))
3670         {
3671           int rc = build_packet( out, node->pkt );
3672           if( rc )
3673             {
3674               log_error("build_packet(%d) failed: %s\n",
3675                         node->pkt->pkttype, g10_errstr(rc) );
3676               return rc;
3677             }
3678         }
3679     }
3680
3681   return 0;
3682 }
3683
3684
3685 /* Note that timestamp is an in/out arg. */
3686 static int
3687 gen_card_key (int algo, int keyno, int is_primary, KBNODE pub_root, 
3688               u32 *timestamp, u32 expireval, struct para_data_s *para)
3689 {
3690 #ifdef ENABLE_CARD_SUPPORT
3691   int rc;
3692   const char *s;
3693   struct agent_card_genkey_s info;
3694   PACKET *pkt;
3695   PKT_secret_key *sk;
3696   PKT_public_key *pk;
3697
3698   assert (algo == PUBKEY_ALGO_RSA);
3699   
3700   /* Fixme: We don't have the serialnumber available, thus passing NULL. */
3701   rc = agent_scd_genkey (&info, keyno, 1, NULL, *timestamp);
3702 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3703 /*      { */
3704 /*        tty_printf ("\n"); */
3705 /*        log_error ("WARNING: key does already exists!\n"); */
3706 /*        tty_printf ("\n"); */
3707 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3708 /*                                    _("Replace existing key? "))) */
3709 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3710 /*      } */
3711
3712   if (rc)
3713     {
3714       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3715       return rc;
3716     }
3717   if ( !info.n || !info.e )
3718     {
3719       log_error ("communication error with SCD\n");
3720       gcry_mpi_release (info.n);
3721       gcry_mpi_release (info.e);
3722       return gpg_error (GPG_ERR_GENERAL);
3723     }
3724   
3725   if (*timestamp != info.created_at)
3726     log_info ("Note that the key does not use the suggested creation date\n");
3727   *timestamp = info.created_at;
3728
3729   pk = xcalloc (1, sizeof *pk );
3730   sk = xcalloc (1, sizeof *sk );
3731   sk->timestamp = pk->timestamp = info.created_at;
3732   sk->version = pk->version = 4;
3733   if (expireval)
3734       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3735   sk->pubkey_algo = pk->pubkey_algo = algo;
3736   pk->pkey[0] = info.n;
3737   pk->pkey[1] = info.e; 
3738   sk->skey[0] = gcry_mpi_copy (pk->pkey[0]);
3739   sk->skey[1] = gcry_mpi_copy (pk->pkey[1]);
3740   sk->skey[2] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
3741   sk->is_protected = 1;
3742   sk->protect.s2k.mode = 1002;
3743   s = get_parameter_value (para, pSERIALNO);
3744   if (s)
3745     {
3746       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3747            sk->protect.ivlen++, s += 2)
3748         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3749     }
3750
3751   if( ret_sk )
3752     *ret_sk = sk;
3753
3754   pkt = xcalloc (1,sizeof *pkt);
3755   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3756   pkt->pkt.public_key = pk;
3757   add_kbnode(pub_root, new_kbnode( pkt ));
3758
3759   pkt = xcalloc (1,sizeof *pkt);
3760   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3761   pkt->pkt.secret_key = sk;
3762   add_kbnode(sec_root, new_kbnode( pkt ));
3763
3764   return 0;
3765 #else
3766   return gpg_error (GPG_ERR_NOT_SUPPORTED);
3767 #endif /*!ENABLE_CARD_SUPPORT*/
3768 }
3769
3770
3771
3772 static int
3773 gen_card_key_with_backup (int algo, int keyno, int is_primary,
3774                           KBNODE pub_root, u32 timestamp,
3775                           u32 expireval, struct para_data_s *para,
3776                           const char *backup_dir)
3777 {
3778 #ifdef ENABLE_CARD_SUPPORT
3779   int rc;
3780   const char *s;
3781   PACKET *pkt;
3782   PKT_secret_key *sk, *sk_unprotected = NULL, *sk_protected = NULL;
3783   PKT_public_key *pk;
3784   size_t n;
3785   int i;
3786   unsigned int nbits;
3787     
3788   /* Get the size of the key directly from the card.  */
3789   {
3790     struct agent_card_info_s info;
3791     
3792     memset (&info, 0, sizeof info);
3793     if (!agent_scd_getattr ("KEY-ATTR", &info)
3794         && info.key_attr[1].algo)
3795       nbits = info.key_attr[1].nbits;
3796     else
3797       nbits = 1024; /* All pre-v2.0 cards.  */
3798     agent_release_card_info (&info);
3799   }
3800
3801   /* Create a key of this size in memory.  */
3802   rc = generate_raw_key (algo, nbits, timestamp,
3803                          &sk_unprotected, &sk_protected);
3804   if (rc)
3805     return rc;
3806
3807   /* Store the key to the card. */
3808   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
3809   if (rc)
3810     {
3811       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
3812       free_secret_key (sk_unprotected);
3813       free_secret_key (sk_protected);
3814       write_status_errcode ("save_key_to_card", rc);
3815       return rc;
3816     }
3817
3818   /* Get rid of the secret key parameters and store the serial numer. */
3819   sk = sk_unprotected;
3820   n = pubkey_get_nskey (sk->pubkey_algo);
3821   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
3822     {
3823       gcry_mpi_release (sk->skey[i]);
3824       sk->skey[i] = NULL;
3825     }
3826   i = pubkey_get_npkey (sk->pubkey_algo);
3827   sk->skey[i] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
3828   sk->is_protected = 1;
3829   sk->protect.s2k.mode = 1002;
3830   s = get_parameter_value (para, pSERIALNO);
3831   assert (s);
3832   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3833        sk->protect.ivlen++, s += 2)
3834     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3835
3836   /* Now write the *protected* secret key to the file.  */
3837   {
3838     char name_buffer[50];
3839     char *fname;
3840     IOBUF fp;
3841     mode_t oldmask;
3842
3843     keyid_from_sk (sk, NULL);
3844     snprintf (name_buffer, sizeof name_buffer, "sk_%08lX%08lX.gpg",
3845               (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
3846
3847     fname = make_filename (backup_dir, name_buffer, NULL);
3848     oldmask = umask (077);
3849     if (is_secured_filename (fname))
3850       {
3851         fp = NULL;
3852         gpg_err_set_errno (EPERM);
3853       }
3854     else
3855       fp = iobuf_create (fname);
3856     umask (oldmask);
3857     if (!fp) 
3858       {
3859         rc = gpg_error_from_syserror ();
3860         log_error (_("can't create backup file `%s': %s\n"),
3861                    fname, strerror(errno) );
3862         xfree (fname);
3863         free_secret_key (sk_unprotected);
3864         free_secret_key (sk_protected);
3865         return rc;
3866       }
3867
3868     pkt = xcalloc (1, sizeof *pkt);
3869     pkt->pkttype = PKT_SECRET_KEY;
3870     pkt->pkt.secret_key = sk_protected;
3871     sk_protected = NULL;
3872
3873     rc = build_packet (fp, pkt);
3874     if (rc)
3875       {
3876         log_error("build packet failed: %s\n", g10_errstr(rc) );
3877         iobuf_cancel (fp);
3878       }
3879     else
3880       {
3881         unsigned char array[MAX_FINGERPRINT_LEN];
3882         char *fprbuf, *p;
3883        
3884         iobuf_close (fp);
3885         iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
3886         log_info (_("NOTE: backup of card key saved to `%s'\n"), fname);
3887
3888         fingerprint_from_sk (sk, array, &n);
3889         p = fprbuf = xmalloc (MAX_FINGERPRINT_LEN*2 + 1 + 1);
3890         for (i=0; i < n ; i++, p += 2)
3891           sprintf (p, "%02X", array[i]);
3892         *p++ = ' ';
3893         *p = 0;
3894
3895         write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED,
3896                                       fprbuf,
3897                                       fname, strlen (fname),
3898                                       0);
3899         xfree (fprbuf);
3900       }
3901     free_packet (pkt);
3902     xfree (pkt);
3903     xfree (fname);
3904     if (rc)
3905       {
3906         free_secret_key (sk_unprotected);
3907         return rc;
3908       }
3909   }
3910
3911   /* Create the public key from the secret key. */
3912   pk = xcalloc (1, sizeof *pk );
3913   pk->timestamp = sk->timestamp;
3914   pk->version = sk->version;
3915   if (expireval)
3916       pk->expiredate = sk->expiredate = sk->timestamp + expireval;
3917   pk->pubkey_algo = sk->pubkey_algo;
3918   n = pubkey_get_npkey (sk->pubkey_algo);
3919   for (i=0; i < n; i++)
3920     pk->pkey[i] = mpi_copy (sk->skey[i]);
3921
3922   /* Build packets and add them to the node lists.  */
3923   pkt = xcalloc (1,sizeof *pkt);
3924   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3925   pkt->pkt.public_key = pk;
3926   add_kbnode(pub_root, new_kbnode( pkt ));
3927
3928   pkt = xcalloc (1,sizeof *pkt);
3929   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3930   pkt->pkt.secret_key = sk;
3931   add_kbnode(sec_root, new_kbnode( pkt ));
3932
3933   return 0;
3934 #else
3935   return gpg_error (GPG_ERR_NOT_SUPPORTED);
3936 #endif /*!ENABLE_CARD_SUPPORT*/
3937 }
3938
3939
3940 #ifdef ENABLE_CARD_SUPPORT
3941 int
3942 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
3943 {
3944   int rc;
3945   unsigned char *rsa_n = NULL;
3946   unsigned char *rsa_e = NULL;
3947   unsigned char *rsa_p = NULL;
3948   unsigned char *rsa_q = NULL;
3949   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
3950   unsigned char *sexp = NULL;
3951   unsigned char *p;
3952   char numbuf[55], numbuf2[50];
3953
3954   assert (is_RSA (sk->pubkey_algo));
3955   assert (!sk->is_protected);
3956
3957   /* Copy the parameters into straight buffers. */
3958   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_n, &rsa_n_len, sk->skey[0]);
3959   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_e, &rsa_e_len, sk->skey[1]);
3960   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_p, &rsa_p_len, sk->skey[3]);
3961   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_q, &rsa_q_len, sk->skey[4]);
3962   if (!rsa_n || !rsa_e || !rsa_p || !rsa_q)
3963     {
3964       rc = G10ERR_INV_ARG;
3965       goto leave;
3966     }
3967
3968    /* Put the key into an S-expression. */
3969   sexp = p = xmalloc_secure (30
3970                              + rsa_n_len + rsa_e_len + rsa_p_len + rsa_q_len
3971                              + 4*sizeof (numbuf) + 25 + sizeof(numbuf) + 20);
3972
3973   p = stpcpy (p,"(11:private-key(3:rsa(1:n");
3974   sprintf (numbuf, "%u:", (unsigned int)rsa_n_len);
3975   p = stpcpy (p, numbuf);
3976   memcpy (p, rsa_n, rsa_n_len);
3977   p += rsa_n_len;
3978
3979   sprintf (numbuf, ")(1:e%u:", (unsigned int)rsa_e_len);
3980   p = stpcpy (p, numbuf);
3981   memcpy (p, rsa_e, rsa_e_len);
3982   p += rsa_e_len;
3983
3984   sprintf (numbuf, ")(1:p%u:", (unsigned int)rsa_p_len);
3985   p = stpcpy (p, numbuf);
3986   memcpy (p, rsa_p, rsa_p_len);
3987   p += rsa_p_len;
3988
3989   sprintf (numbuf, ")(1:q%u:", (unsigned int)rsa_q_len);
3990   p = stpcpy (p, numbuf);
3991   memcpy (p, rsa_q, rsa_q_len);
3992   p += rsa_q_len;
3993
3994   p = stpcpy (p,"))(10:created-at");
3995   sprintf (numbuf2, "%lu", (unsigned long)sk->timestamp);
3996   sprintf (numbuf, "%lu:", (unsigned long)strlen (numbuf2));
3997   p = stpcpy (stpcpy (stpcpy (p, numbuf), numbuf2), "))");
3998
3999   /* Fixme: Unfortunately we don't have the serialnumber available -
4000      thus we can't pass it down to the agent. */ 
4001   rc = agent_scd_writekey (keyno, NULL, sexp, p - sexp);
4002
4003  leave:
4004   xfree (sexp);
4005   xfree (rsa_n);
4006   xfree (rsa_e);
4007   xfree (rsa_p);
4008   xfree (rsa_q);
4009   return rc;
4010 }
4011 #endif /*ENABLE_CARD_SUPPORT*/