Exporting secret keys via gpg-agent is now basically supported.
[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, const char *cache_nonce)
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, cache_nonce);
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                   const char *cache_nonce)
923 {
924   gpg_error_t err;
925   PACKET *pkt;
926   PKT_signature *sig;
927   KBNODE node;
928   PKT_public_key *pk;
929
930   if (opt.verbose)
931     log_info (_("writing direct signature\n"));
932
933   /* Get the pk packet from the pub_tree. */
934   node = find_kbnode (root, PKT_PUBLIC_KEY);
935   if (!node)
936     BUG ();
937   pk = node->pkt->pkt.public_key;
938
939   /* We have to cache the key, so that the verification of the
940      signature creation is able to retrieve the public key.  */
941   cache_public_key (pk);
942
943   /* Make the signature.  */
944   err = make_keysig_packet (&sig, pk, NULL,NULL, psk, 0x1F,
945                             0, 0, timestamp, 0,
946                             keygen_add_revkey, revkey, cache_nonce);
947   if (err)
948     {
949       log_error ("make_keysig_packet failed: %s\n", g10_errstr (err) );
950       return err;
951     }
952   
953   pkt = xmalloc_clear (sizeof *pkt);
954   pkt->pkttype = PKT_SIGNATURE;
955   pkt->pkt.signature = sig;
956   add_kbnode (root, new_kbnode (pkt));
957   return err;
958 }
959
960
961
962 /* Write a self-signature to the first user id in ROOT using the key
963    PSK.  USE and TIMESTAMP give the extra data we need for the
964    signature.  */
965 static gpg_error_t
966 write_selfsigs (KBNODE root, PKT_public_key *psk,
967                 unsigned int use, u32 timestamp, const char *cache_nonce)
968 {
969   gpg_error_t err;
970   PACKET *pkt;
971   PKT_signature *sig;
972   PKT_user_id *uid;
973   KBNODE node;
974   PKT_public_key *pk;
975
976   if (opt.verbose)
977     log_info (_("writing self signature\n"));
978
979   /* Get the uid packet from the list. */
980   node = find_kbnode (root, PKT_USER_ID);
981   if (!node)
982     BUG(); /* No user id packet in tree.  */
983   uid = node->pkt->pkt.user_id;
984
985   /* Get the pk packet from the pub_tree. */
986   node = find_kbnode (root, PKT_PUBLIC_KEY);
987   if (!node)
988     BUG();
989   pk = node->pkt->pkt.public_key;
990
991   /* The usage has not yet been set - do it now. */
992   pk->pubkey_usage = use;
993  
994   /* We have to cache the key, so that the verification of the
995      signature creation is able to retrieve the public key.  */
996   cache_public_key (pk);
997
998   /* Make the signature.  */
999   err = make_keysig_packet (&sig, pk, uid, NULL, psk, 0x13,
1000                             0, 0, timestamp, 0,
1001                             keygen_add_std_prefs, pk, cache_nonce);
1002   if (err) 
1003     {
1004       log_error ("make_keysig_packet failed: %s\n", g10_errstr (err));
1005       return err;
1006     }
1007
1008   pkt = xmalloc_clear (sizeof *pkt);
1009   pkt->pkttype = PKT_SIGNATURE;
1010   pkt->pkt.signature = sig;
1011   add_kbnode (root, new_kbnode (pkt));
1012
1013   return err;
1014 }
1015
1016
1017 /* Write the key binding signature.  If TIMESTAMP is not NULL use the
1018    signature creation time.  PRI_PSK is the key use for signing.
1019    SUB_PSK is a key used to create a back-signature; that one is only
1020    used if USE has the PUBKEY_USAGE_SIG capability.  */
1021 static int
1022 write_keybinding (KBNODE root, PKT_public_key *pri_psk, PKT_public_key *sub_psk,
1023                   unsigned int use, u32 timestamp, const char *cache_nonce)
1024 {
1025   gpg_error_t err;
1026   PACKET *pkt;
1027   PKT_signature *sig;
1028   KBNODE node;
1029   PKT_public_key *pri_pk, *sub_pk;
1030   struct opaque_data_usage_and_pk oduap;
1031
1032   if (opt.verbose)
1033     log_info(_("writing key binding signature\n"));
1034
1035   /* Get the primary pk packet from the tree.  */
1036   node = find_kbnode (root, PKT_PUBLIC_KEY);
1037   if (!node)
1038     BUG();
1039   pri_pk = node->pkt->pkt.public_key;
1040
1041   /* We have to cache the key, so that the verification of the
1042    * signature creation is able to retrieve the public key.  */
1043   cache_public_key (pri_pk);
1044  
1045   /* Find the last subkey. */
1046   sub_pk = NULL;
1047   for (node = root; node; node = node->next ) 
1048     {
1049       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1050         sub_pk = node->pkt->pkt.public_key;
1051     }
1052   if (!sub_pk)
1053     BUG();
1054
1055   /* Make the signature.  */
1056   oduap.usage = use;
1057   oduap.pk = sub_pk;
1058   err = make_keysig_packet (&sig, pri_pk, NULL, sub_pk, pri_psk, 0x18, 
1059                             0, 0, timestamp, 0,
1060                             keygen_add_key_flags_and_expire, &oduap,
1061                             cache_nonce);
1062   if (err) 
1063     {
1064       log_error ("make_keysig_packet failed: %s\n", g10_errstr (err));
1065       return err;
1066     }
1067
1068   /* Make a backsig.  */
1069   if (use & PUBKEY_USAGE_SIG)
1070     {
1071       err = make_backsig (sig, pri_pk, sub_pk, sub_psk, timestamp, cache_nonce);
1072       if (err)
1073         return err;
1074     }
1075   
1076   pkt = xmalloc_clear ( sizeof *pkt );
1077   pkt->pkttype = PKT_SIGNATURE;
1078   pkt->pkt.signature = sig;
1079   add_kbnode (root, new_kbnode (pkt) );
1080   return err;
1081 }
1082
1083
1084
1085 static int
1086 key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
1087                const char *topname, const char *elems)
1088 {
1089   gcry_sexp_t list, l2;
1090   const char *s;
1091   int i, idx;
1092   int rc = 0;
1093
1094   list = gcry_sexp_find_token (sexp, topname, 0);
1095   if (!list)
1096     return gpg_error (GPG_ERR_INV_OBJ);
1097   l2 = gcry_sexp_cadr (list);
1098   gcry_sexp_release (list);
1099   list = l2;
1100   if (!list)
1101     return gpg_error (GPG_ERR_NO_OBJ);
1102
1103   for (idx=0,s=elems; *s; s++, idx++)
1104     {
1105       l2 = gcry_sexp_find_token (list, s, 1);
1106       if (!l2)
1107         {
1108           rc = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
1109           goto leave;
1110         }
1111       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1112       gcry_sexp_release (l2);
1113       if (!array[idx]) 
1114         {
1115           rc = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
1116           goto leave;
1117         }
1118     }
1119   gcry_sexp_release (list);
1120
1121  leave:
1122   if (rc)
1123     {
1124       for (i=0; i<idx; i++)
1125         {
1126           gcry_mpi_release (array[i]);
1127           array[i] = NULL;
1128         }
1129       gcry_sexp_release (list);
1130     }
1131   return rc;
1132 }
1133
1134
1135
1136 /* Common code for the key generation fucntion gen_xxx.  */
1137 static int
1138 common_gen (const char *keyparms, int algo, const char *algoelem,
1139             kbnode_t pub_root, u32 timestamp, u32 expireval, int is_subkey,
1140             char **cache_nonce_addr)
1141 {
1142   int err;
1143   PACKET *pkt;
1144   PKT_public_key *pk;
1145   gcry_sexp_t s_key;
1146   
1147   err = agent_genkey (NULL, cache_nonce_addr, keyparms, &s_key);
1148   if (err)
1149     {
1150       log_error ("agent_genkey failed: %s\n", gpg_strerror (err) );
1151       return err;
1152     }
1153   
1154   pk = xtrycalloc (1, sizeof *pk);
1155   if (!pk)
1156     {
1157       err = gpg_error_from_syserror ();
1158       gcry_sexp_release (s_key);
1159       return err;
1160     }
1161
1162   pk->timestamp = timestamp;
1163   pk->version = 4;
1164   if (expireval) 
1165     pk->expiredate = pk->timestamp + expireval;
1166   pk->pubkey_algo = algo;
1167
1168   err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
1169   if (err) 
1170     {
1171       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
1172       gcry_sexp_release (s_key);
1173       free_public_key (pk);
1174       return err;
1175     }
1176   gcry_sexp_release (s_key);
1177   
1178   pkt = xtrycalloc (1, sizeof *pkt);
1179   if (!pkt)
1180     {
1181       err = gpg_error_from_syserror ();
1182       free_public_key (pk);
1183       return err;
1184     }
1185
1186   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1187   pkt->pkt.public_key = pk;
1188   add_kbnode (pub_root, new_kbnode (pkt));
1189
1190   return 0;
1191 }
1192
1193
1194 /*
1195  * Generate an Elgamal key.
1196  */
1197 static int
1198 gen_elg (int algo, unsigned int nbits, KBNODE pub_root,
1199          u32 timestamp, u32 expireval, int is_subkey, char **cache_nonce_addr)
1200 {
1201   int err;
1202   char *keyparms;
1203   char nbitsstr[35];
1204   
1205   assert (is_ELGAMAL (algo));
1206
1207   if (nbits < 512)
1208     {
1209       nbits = 1024;
1210       log_info (_("keysize invalid; using %u bits\n"), nbits );
1211     }
1212
1213   if ((nbits % 32))
1214     {
1215       nbits = ((nbits + 31) / 32) * 32;
1216       log_info (_("keysize rounded up to %u bits\n"), nbits );
1217     }
1218
1219   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1220   keyparms = xtryasprintf ("(genkey(%s(nbits %zu:%s)))",
1221                            algo == GCRY_PK_ELG_E ? "openpgp-elg" :
1222                            algo == GCRY_PK_ELG   ? "elg" : "x-oops" ,
1223                            strlen (nbitsstr), nbitsstr);
1224   if (!keyparms)
1225     err = gpg_error_from_syserror ();
1226   else
1227     {
1228       err = common_gen (keyparms, algo, "pgy", 
1229                         pub_root, timestamp, expireval, is_subkey,
1230                         cache_nonce_addr);
1231       xfree (keyparms);
1232     }
1233
1234   return err;
1235 }
1236
1237
1238 /*
1239  * Generate an DSA key
1240  */
1241 static gpg_error_t
1242 gen_dsa (unsigned int nbits, KBNODE pub_root, 
1243          u32 timestamp, u32 expireval, int is_subkey, char **cache_nonce_addr)
1244 {
1245   int err;
1246   unsigned int qbits;
1247   char *keyparms;
1248   char nbitsstr[35];
1249   char qbitsstr[35];
1250
1251   if ( nbits < 512) 
1252     {
1253       nbits = 1024;
1254       log_info(_("keysize invalid; using %u bits\n"), nbits );
1255     }
1256   else if ( nbits > 3072 )
1257     {
1258       nbits = 3072;
1259       log_info(_("keysize invalid; using %u bits\n"), nbits );
1260     }
1261
1262   if( (nbits % 64) )
1263     {
1264       nbits = ((nbits + 63) / 64) * 64;
1265       log_info(_("keysize rounded up to %u bits\n"), nbits );
1266     }
1267
1268   /* To comply with FIPS rules we round up to the next value unless in
1269      expert mode.  */
1270   if (!opt.expert && nbits > 1024 && (nbits % 1024))
1271     {
1272       nbits = ((nbits + 1023) / 1024) * 1024;
1273       log_info(_("keysize rounded up to %u bits\n"), nbits );
1274     }
1275
1276   /*
1277     Figure out a q size based on the key size.  FIPS 180-3 says:
1278  
1279     L = 1024, N = 160
1280     L = 2048, N = 224
1281     L = 2048, N = 256
1282     L = 3072, N = 256
1283  
1284     2048/256 is an odd pair since there is also a 2048/224 and
1285     3072/256.  Matching sizes is not a very exact science.
1286       
1287     We'll do 256 qbits for nbits over 2047, 224 for nbits over 1024
1288     but less than 2048, and 160 for 1024 (DSA1).
1289   */
1290  
1291   if (nbits > 2047)
1292     qbits = 256;
1293   else if ( nbits > 1024)
1294     qbits = 224;
1295   else
1296     qbits = 160;
1297  
1298   if (qbits != 160 )
1299     log_info (_("WARNING: some OpenPGP programs can't"
1300                 " handle a DSA key with this digest size\n"));
1301
1302   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1303   snprintf (qbitsstr, sizeof qbitsstr, "%u", qbits);
1304   keyparms = xtryasprintf ("(genkey(dsa(nbits %zu:%s)(qbits %zu:%s)))",
1305                            strlen (nbitsstr), nbitsstr,
1306                            strlen (qbitsstr), qbitsstr);
1307   if (!keyparms)
1308     err = gpg_error_from_syserror ();
1309   else
1310     {
1311       err = common_gen (keyparms, PUBKEY_ALGO_DSA, "pqgy", 
1312                         pub_root, timestamp, expireval, is_subkey,
1313                         cache_nonce_addr);
1314       xfree (keyparms);
1315     }
1316
1317   return err;
1318 }
1319
1320
1321 /* 
1322  * Generate an RSA key.
1323  */
1324 static int
1325 gen_rsa (int algo, unsigned int nbits, KBNODE pub_root,
1326          u32 timestamp, u32 expireval, int is_subkey, char **cache_nonce_addr)
1327 {
1328   int err;
1329   char *keyparms;
1330   char nbitsstr[35];
1331
1332   assert (is_RSA(algo));
1333
1334   if (!nbits)
1335     nbits = DEFAULT_STD_KEYSIZE;
1336
1337   if (nbits < 1024) 
1338     {
1339       nbits = 1024;
1340       log_info (_("keysize invalid; using %u bits\n"), nbits );
1341     }
1342   
1343   if ((nbits % 32))
1344     {
1345       nbits = ((nbits + 31) / 32) * 32;
1346       log_info (_("keysize rounded up to %u bits\n"), nbits );
1347     }
1348
1349   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
1350   keyparms = xtryasprintf ("(genkey(rsa(nbits %zu:%s)))", 
1351                            strlen (nbitsstr), nbitsstr);
1352   if (!keyparms)
1353     err = gpg_error_from_syserror ();
1354   else
1355     {
1356       err = common_gen (keyparms, algo, "ne", 
1357                         pub_root, timestamp, expireval, is_subkey,
1358                         cache_nonce_addr);
1359       xfree (keyparms);
1360     }
1361
1362   return err;
1363 }
1364
1365
1366 /****************
1367  * check valid days:
1368  * return 0 on error or the multiplier
1369  */
1370 static int
1371 check_valid_days( const char *s )
1372 {
1373     if( !digitp(s) )
1374         return 0;
1375     for( s++; *s; s++)
1376         if( !digitp(s) )
1377             break;
1378     if( !*s )
1379         return 1;
1380     if( s[1] )
1381         return 0; /* e.g. "2323wc" */
1382     if( *s == 'd' || *s == 'D' )
1383         return 1;
1384     if( *s == 'w' || *s == 'W' )
1385         return 7;
1386     if( *s == 'm' || *s == 'M' )
1387         return 30;
1388     if( *s == 'y' || *s == 'Y' )
1389         return 365;
1390     return 0;
1391 }
1392
1393
1394 static void
1395 print_key_flags(int flags)
1396 {
1397   if(flags&PUBKEY_USAGE_SIG)
1398     tty_printf("%s ",_("Sign"));
1399
1400   if(flags&PUBKEY_USAGE_CERT)
1401     tty_printf("%s ",_("Certify"));
1402
1403   if(flags&PUBKEY_USAGE_ENC)
1404     tty_printf("%s ",_("Encrypt"));
1405
1406   if(flags&PUBKEY_USAGE_AUTH)
1407     tty_printf("%s ",_("Authenticate"));
1408 }
1409
1410
1411 /* Returns the key flags */
1412 static unsigned int
1413 ask_key_flags(int algo,int subkey)
1414 {
1415   /* TRANSLATORS: Please use only plain ASCII characters for the
1416      translation.  If this is not possible use single digits.  The
1417      string needs to 8 bytes long. Here is a description of the
1418      functions:
1419
1420        s = Toggle signing capability
1421        e = Toggle encryption capability
1422        a = Toggle authentication capability
1423        q = Finish
1424   */
1425   const char *togglers=_("SsEeAaQq");
1426   char *answer=NULL;
1427   unsigned int current=0;
1428   unsigned int possible=openpgp_pk_algo_usage(algo);
1429
1430   if ( strlen(togglers) != 8 )
1431     {
1432       tty_printf ("NOTE: Bad translation at %s:%d. "
1433                   "Please report.\n", __FILE__, __LINE__);
1434       togglers = "11223300";
1435     }
1436
1437   /* Only primary keys may certify. */
1438   if(subkey)
1439     possible&=~PUBKEY_USAGE_CERT;
1440
1441   /* Preload the current set with the possible set, minus
1442      authentication, since nobody really uses auth yet. */
1443   current=possible&~PUBKEY_USAGE_AUTH;
1444
1445   for(;;)
1446     {
1447       tty_printf("\n");
1448       tty_printf(_("Possible actions for a %s key: "),
1449                  gcry_pk_algo_name (algo));
1450       print_key_flags(possible);
1451       tty_printf("\n");
1452       tty_printf(_("Current allowed actions: "));
1453       print_key_flags(current);
1454       tty_printf("\n\n");
1455
1456       if(possible&PUBKEY_USAGE_SIG)
1457         tty_printf(_("   (%c) Toggle the sign capability\n"),
1458                    togglers[0]);
1459       if(possible&PUBKEY_USAGE_ENC)
1460         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
1461                    togglers[2]);
1462       if(possible&PUBKEY_USAGE_AUTH)
1463         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
1464                    togglers[4]);
1465
1466       tty_printf(_("   (%c) Finished\n"),togglers[6]);
1467       tty_printf("\n");
1468
1469       xfree(answer);
1470       answer = cpr_get("keygen.flags",_("Your selection? "));
1471       cpr_kill_prompt();
1472
1473       if(strlen(answer)>1)
1474         tty_printf(_("Invalid selection.\n"));
1475       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1476         break;
1477       else if((*answer==togglers[0] || *answer==togglers[1])
1478               && possible&PUBKEY_USAGE_SIG)
1479         {
1480           if(current&PUBKEY_USAGE_SIG)
1481             current&=~PUBKEY_USAGE_SIG;
1482           else
1483             current|=PUBKEY_USAGE_SIG;
1484         }
1485       else if((*answer==togglers[2] || *answer==togglers[3])
1486               && possible&PUBKEY_USAGE_ENC)
1487         {
1488           if(current&PUBKEY_USAGE_ENC)
1489             current&=~PUBKEY_USAGE_ENC;
1490           else
1491             current|=PUBKEY_USAGE_ENC;
1492         }
1493       else if((*answer==togglers[4] || *answer==togglers[5])
1494               && possible&PUBKEY_USAGE_AUTH)
1495         {
1496           if(current&PUBKEY_USAGE_AUTH)
1497             current&=~PUBKEY_USAGE_AUTH;
1498           else
1499             current|=PUBKEY_USAGE_AUTH;
1500         }
1501       else
1502         tty_printf(_("Invalid selection.\n"));
1503     }
1504
1505   xfree(answer);
1506
1507   return current;
1508 }
1509
1510
1511 /* Ask for an algorithm.  The function returns the algorithm id to
1512  * create. If ADDMODE is false the function won't show an option to
1513  * create the primary and subkey combined and won't set R_USAGE
1514  * either.  If a combined algorithm has been selected, the subkey
1515  * algorithm is stored at R_SUBKEY_ALGO.  */
1516 static int
1517 ask_algo (int addmode, int *r_subkey_algo, unsigned int *r_usage)
1518 {
1519   char *answer;
1520   int algo;
1521   int dummy_algo;
1522
1523   if (!r_subkey_algo)
1524     r_subkey_algo = &dummy_algo;
1525   
1526   tty_printf (_("Please select what kind of key you want:\n"));
1527
1528   if (!addmode)
1529     tty_printf (_("   (%d) RSA and RSA (default)\n"), 1 );
1530   if (!addmode)
1531     tty_printf (_("   (%d) DSA and Elgamal\n"), 2 );
1532
1533   tty_printf (_("   (%d) DSA (sign only)\n"), 3 );
1534   tty_printf (_("   (%d) RSA (sign only)\n"), 4 );
1535
1536   if (addmode)
1537     {
1538       tty_printf (_("   (%d) Elgamal (encrypt only)\n"), 5 );
1539       tty_printf (_("   (%d) RSA (encrypt only)\n"), 6 );
1540     }
1541   if (opt.expert)
1542     {
1543       tty_printf (_("   (%d) DSA (set your own capabilities)\n"), 7 );
1544       tty_printf (_("   (%d) RSA (set your own capabilities)\n"), 8 );
1545     }
1546   
1547   for(;;)
1548     {
1549       *r_usage = 0;
1550       *r_subkey_algo = 0;
1551       answer = cpr_get ("keygen.algo", _("Your selection? "));
1552       cpr_kill_prompt ();
1553       algo = *answer? atoi (answer) : 1;
1554       xfree(answer);
1555       if (algo == 1 && !addmode)
1556         {
1557           algo = PUBKEY_ALGO_RSA;
1558           *r_subkey_algo = PUBKEY_ALGO_RSA;
1559           break;
1560         }
1561       else if (algo == 2 && !addmode)
1562         {
1563           algo = PUBKEY_ALGO_DSA;
1564           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
1565           break;
1566         }
1567       else if (algo == 3)
1568         {
1569           algo = PUBKEY_ALGO_DSA;
1570           *r_usage = PUBKEY_USAGE_SIG;
1571           break;
1572         }
1573       else if (algo == 4)
1574         {
1575           algo = PUBKEY_ALGO_RSA;
1576           *r_usage = PUBKEY_USAGE_SIG;
1577           break;
1578         }
1579       else if (algo == 5 && addmode)
1580         {
1581           algo = PUBKEY_ALGO_ELGAMAL_E;
1582           *r_usage = PUBKEY_USAGE_ENC;
1583           break;
1584         }
1585       else if (algo == 6 && addmode)
1586         {
1587           algo = PUBKEY_ALGO_RSA;
1588           *r_usage = PUBKEY_USAGE_ENC;
1589           break;
1590         }
1591       else if (algo == 7 && opt.expert)
1592         {
1593           algo = PUBKEY_ALGO_DSA;
1594           *r_usage = ask_key_flags (algo, addmode);
1595           break;
1596         }
1597       else if (algo == 8 && opt.expert)
1598         {
1599           algo = PUBKEY_ALGO_RSA;
1600           *r_usage = ask_key_flags (algo, addmode);
1601           break;
1602         }
1603       else
1604         tty_printf (_("Invalid selection.\n"));
1605     }
1606   
1607   return algo;
1608 }
1609
1610
1611 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
1612    is not 0, the function asks for the size of the encryption
1613    subkey. */
1614 static unsigned
1615 ask_keysize (int algo, unsigned int primary_keysize)
1616 {
1617   unsigned int nbits, min, def = DEFAULT_STD_KEYSIZE, max=4096;
1618   int for_subkey = !!primary_keysize;
1619   int autocomp = 0;
1620
1621   if(opt.expert)
1622     min=512;
1623   else
1624     min=1024;
1625
1626   if (primary_keysize && !opt.expert)
1627     {
1628       /* Deduce the subkey size from the primary key size.  */
1629       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
1630         nbits = 3072; /* For performance reasons we don't support more
1631                          than 3072 bit DSA.  However we won't see this
1632                          case anyway because DSA can't be used as an
1633                          encryption subkey ;-). */
1634       else
1635         nbits = primary_keysize;
1636       autocomp = 1;
1637       goto leave;
1638     }
1639
1640   switch(algo)
1641     {
1642     case PUBKEY_ALGO_DSA:
1643       def=2048;
1644       max=3072;
1645       break;
1646
1647     case PUBKEY_ALGO_RSA:
1648       min=1024;
1649       break;
1650     }
1651
1652   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
1653              gcry_pk_algo_name (algo), min, max);
1654
1655   for(;;)
1656     {
1657       char *prompt, *answer;
1658
1659       if (for_subkey)
1660         prompt = xasprintf (_("What keysize do you want "
1661                               "for the subkey? (%u) "), def);
1662       else
1663         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
1664       answer = cpr_get ("keygen.size", prompt);
1665       cpr_kill_prompt ();
1666       nbits = *answer? atoi (answer): def;
1667       xfree(prompt);
1668       xfree(answer);
1669       
1670       if(nbits<min || nbits>max)
1671         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
1672                    gcry_pk_algo_name (algo), min, max);
1673       else
1674         break;
1675     }
1676
1677   tty_printf(_("Requested keysize is %u bits\n"), nbits );
1678
1679  leave:
1680   if( algo == PUBKEY_ALGO_DSA && (nbits % 64) )
1681     {
1682       nbits = ((nbits + 63) / 64) * 64;
1683       if (!autocomp)
1684         tty_printf(_("rounded up to %u bits\n"), nbits );
1685     }
1686   else if( (nbits % 32) )
1687     {
1688       nbits = ((nbits + 31) / 32) * 32;
1689       if (!autocomp)
1690         tty_printf(_("rounded up to %u bits\n"), nbits );
1691     }
1692
1693   return nbits;
1694 }
1695
1696
1697 /****************
1698  * Parse an expire string and return its value in seconds.
1699  * Returns (u32)-1 on error.
1700  * This isn't perfect since scan_isodatestr returns unix time, and
1701  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
1702  * Because of this, we only permit setting expirations up to 2106, but
1703  * OpenPGP could theoretically allow up to 2242.  I think we'll all
1704  * just cope for the next few years until we get a 64-bit time_t or
1705  * similar.
1706  */
1707 u32
1708 parse_expire_string( const char *string )
1709 {
1710   int mult;
1711   u32 seconds;
1712   u32 abs_date = 0;
1713   u32 curtime = make_timestamp ();
1714   time_t tt;
1715   
1716   if (!*string)
1717     seconds = 0;
1718   else if (!strncmp (string, "seconds=", 8))
1719     seconds = atoi (string+8);
1720   else if ((abs_date = scan_isodatestr(string))
1721            && (abs_date+86400/2) > curtime)
1722     seconds = (abs_date+86400/2) - curtime;
1723   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
1724     seconds = (u32)tt - curtime;
1725   else if ((mult = check_valid_days (string)))
1726     seconds = atoi (string) * 86400L * mult;
1727   else
1728     seconds = (u32)(-1);
1729   
1730   return seconds;
1731 }
1732
1733 /* Parsean Creation-Date string which is either "1986-04-26" or
1734    "19860426T042640".  Returns 0 on error. */
1735 static u32
1736 parse_creation_string (const char *string)
1737 {
1738   u32 seconds;
1739   
1740   if (!*string)
1741     seconds = 0;
1742   else if ( !strncmp (string, "seconds=", 8) )
1743     seconds = atoi (string+8);
1744   else if ( !(seconds = scan_isodatestr (string)))
1745     {
1746       time_t tmp = isotime2epoch (string);
1747       seconds = (tmp == (time_t)(-1))? 0 : tmp;
1748     }
1749   return seconds;
1750 }
1751
1752
1753 /* object == 0 for a key, and 1 for a sig */
1754 u32
1755 ask_expire_interval(int object,const char *def_expire)
1756 {
1757     u32 interval;
1758     char *answer;
1759
1760     switch(object)
1761       {
1762       case 0:
1763         if(def_expire)
1764           BUG();
1765         tty_printf(_("Please specify how long the key should be valid.\n"
1766                      "         0 = key does not expire\n"
1767                      "      <n>  = key expires in n days\n"
1768                      "      <n>w = key expires in n weeks\n"
1769                      "      <n>m = key expires in n months\n"
1770                      "      <n>y = key expires in n years\n"));
1771         break;
1772
1773       case 1:
1774         if(!def_expire)
1775           BUG();
1776         tty_printf(_("Please specify how long the signature should be valid.\n"
1777                      "         0 = signature does not expire\n"
1778                      "      <n>  = signature expires in n days\n"
1779                      "      <n>w = signature expires in n weeks\n"
1780                      "      <n>m = signature expires in n months\n"
1781                      "      <n>y = signature expires in n years\n"));
1782         break;
1783
1784       default:
1785         BUG();
1786       }
1787
1788     /* Note: The elgamal subkey for DSA has no expiration date because
1789      * it must be signed with the DSA key and this one has the expiration
1790      * date */
1791
1792     answer = NULL;
1793     for(;;)
1794       {
1795         u32 curtime=make_timestamp();
1796
1797         xfree(answer);
1798         if(object==0)
1799           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1800         else
1801           {
1802             char *prompt;
1803
1804 #define PROMPTSTRING _("Signature is valid for? (%s) ")
1805             /* This will actually end up larger than necessary because
1806                of the 2 bytes for '%s' */
1807             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
1808             sprintf(prompt,PROMPTSTRING,def_expire);
1809 #undef PROMPTSTRING
1810
1811             answer = cpr_get("siggen.valid",prompt);
1812             xfree(prompt);
1813
1814             if(*answer=='\0')
1815               answer=xstrdup(def_expire);
1816           }
1817         cpr_kill_prompt();
1818         trim_spaces(answer);
1819         interval = parse_expire_string( answer );
1820         if( interval == (u32)-1 )
1821           {
1822             tty_printf(_("invalid value\n"));
1823             continue;
1824           }
1825
1826         if( !interval )
1827           {
1828             tty_printf((object==0)
1829                        ? _("Key does not expire at all\n")
1830                        : _("Signature does not expire at all\n"));
1831           }
1832         else
1833           {
1834             tty_printf(object==0
1835                        ? _("Key expires at %s\n")
1836                        : _("Signature expires at %s\n"),
1837                        asctimestamp((ulong)(curtime + interval) ) );
1838 #if SIZEOF_TIME_T <= 4
1839             if ( (time_t)((ulong)(curtime+interval)) < 0 )
1840               tty_printf (_("Your system can't display dates beyond 2038.\n"
1841                             "However, it will be correctly handled up to"
1842                             " 2106.\n"));
1843             else
1844 #endif /*SIZEOF_TIME_T*/
1845               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
1846                 {
1847                   tty_printf (_("invalid value\n"));
1848                   continue;
1849                 }
1850           }
1851
1852         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1853                                                    _("Is this correct? (y/N) ")) )
1854           break;
1855       }
1856
1857     xfree(answer);
1858     return interval;
1859 }
1860
1861 u32
1862 ask_expiredate()
1863 {
1864     u32 x = ask_expire_interval(0,NULL);
1865     return x? make_timestamp() + x : 0;
1866 }
1867
1868
1869
1870 static PKT_user_id *
1871 uid_from_string (const char *string)
1872 {
1873   size_t n;
1874   PKT_user_id *uid;
1875
1876   n = strlen (string);
1877   uid = xmalloc_clear (sizeof *uid + n);
1878   uid->len = n;
1879   strcpy (uid->name, string);
1880   uid->ref = 1;
1881   return uid;
1882 }
1883
1884
1885 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
1886    printed for use during a new key creation.  If KEYBLOCK is not NULL
1887    the function prevents the creation of an already existing user
1888    ID.  */
1889 static char *
1890 ask_user_id (int mode, KBNODE keyblock)
1891 {
1892     char *answer;
1893     char *aname, *acomment, *amail, *uid;
1894
1895     if ( !mode )
1896       {
1897         /* TRANSLATORS: This is the new string telling the user what
1898            gpg is now going to do (i.e. ask for the parts of the user
1899            ID).  Note that if you do not tyranslated this string, a
1900            different string will be used used, which might still have
1901            a correct transaltion.  */
1902         const char *s1 =
1903           N_("\n"
1904              "GnuPG needs to construct a user ID to identify your key.\n"
1905              "\n");
1906         const char *s2 = _(s1);
1907
1908         if (!strcmp (s1, s2))
1909           {
1910             /* There is no translation for the string thus we to use
1911                the old info text.  gettext has no way to tell whether
1912                a translation is actually available, thus we need to
1913                to compare again. */
1914             /* TRANSLATORS: This string is in general not anymore used
1915                but you should keep your existing translation.  In case
1916                the new string is not translated this old string will
1917                be used. */
1918             const char *s3 = N_("\n"
1919 "You need a user ID to identify your key; "
1920                                         "the software constructs the user ID\n"
1921 "from the Real Name, Comment and Email Address in this form:\n"
1922 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
1923             const char *s4 = _(s3);
1924             if (strcmp (s3, s4))
1925               s2 = s3; /* A translation exists - use it. */
1926           }
1927         tty_printf ("%s", s2) ;
1928       }
1929     uid = aname = acomment = amail = NULL;
1930     for(;;) {
1931         char *p;
1932         int fail=0;
1933
1934         if( !aname ) {
1935             for(;;) {
1936                 xfree(aname);
1937                 aname = cpr_get("keygen.name",_("Real name: "));
1938                 trim_spaces(aname);
1939                 cpr_kill_prompt();
1940
1941                 if( opt.allow_freeform_uid )
1942                     break;
1943
1944                 if( strpbrk( aname, "<>" ) )
1945                     tty_printf(_("Invalid character in name\n"));
1946                 else if( digitp(aname) )
1947                     tty_printf(_("Name may not start with a digit\n"));
1948                 else if( strlen(aname) < 5 )
1949                     tty_printf(_("Name must be at least 5 characters long\n"));
1950                 else
1951                     break;
1952             }
1953         }
1954         if( !amail ) {
1955             for(;;) {
1956                 xfree(amail);
1957                 amail = cpr_get("keygen.email",_("Email address: "));
1958                 trim_spaces(amail);
1959                 cpr_kill_prompt();
1960                 if( !*amail || opt.allow_freeform_uid )
1961                     break;   /* no email address is okay */
1962                 else if ( !is_valid_mailbox (amail) )
1963                     tty_printf(_("Not a valid email address\n"));
1964                 else
1965                     break;
1966             }
1967         }
1968         if( !acomment ) {
1969             for(;;) {
1970                 xfree(acomment);
1971                 acomment = cpr_get("keygen.comment",_("Comment: "));
1972                 trim_spaces(acomment);
1973                 cpr_kill_prompt();
1974                 if( !*acomment )
1975                     break;   /* no comment is okay */
1976                 else if( strpbrk( acomment, "()" ) )
1977                     tty_printf(_("Invalid character in comment\n"));
1978                 else
1979                     break;
1980             }
1981         }
1982
1983
1984         xfree(uid);
1985         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1986         p = stpcpy(p, aname );
1987         if( *acomment )
1988             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1989         if( *amail )
1990             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1991
1992         /* Append a warning if the RNG is switched into fake mode.  */
1993         if ( random_is_faked ()  )
1994           strcpy(p, " (insecure!)" );
1995
1996         /* print a note in case that UTF8 mapping has to be done */
1997         for(p=uid; *p; p++ ) {
1998             if( *p & 0x80 ) {
1999                 tty_printf(_("You are using the `%s' character set.\n"),
2000                            get_native_charset() );
2001                 break;
2002             }
2003         }
2004
2005         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2006
2007         if( !*amail && !opt.allow_freeform_uid
2008             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2009             fail = 1;
2010             tty_printf(_("Please don't put the email address "
2011                          "into the real name or the comment\n") );
2012         }
2013
2014         if (!fail && keyblock)
2015           {
2016             PKT_user_id *uidpkt = uid_from_string (uid);
2017             KBNODE node;
2018
2019             for (node=keyblock; node && !fail; node=node->next)
2020               if (!is_deleted_kbnode (node)
2021                   && node->pkt->pkttype == PKT_USER_ID
2022                   && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2023                 fail = 1;
2024             if (fail)
2025               tty_printf (_("Such a user ID already exists on this key!\n"));
2026             free_user_id (uidpkt);
2027           }
2028
2029         for(;;) {
2030             /* TRANSLATORS: These are the allowed answers in
2031                lower and uppercase.  Below you will find the matching
2032                string which should be translated accordingly and the
2033                letter changed to match the one in the answer string.
2034                
2035                  n = Change name
2036                  c = Change comment
2037                  e = Change email
2038                  o = Okay (ready, continue)
2039                  q = Quit
2040              */
2041             const char *ansstr = _("NnCcEeOoQq");
2042
2043             if( strlen(ansstr) != 10 )
2044                 BUG();
2045             if( cpr_enabled() ) {
2046                 answer = xstrdup (ansstr + (fail?8:6));
2047                 answer[1] = 0;
2048             }
2049             else {
2050                 answer = cpr_get("keygen.userid.cmd", fail?
2051                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2052                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2053                 cpr_kill_prompt();
2054             }
2055             if( strlen(answer) > 1 )
2056                 ;
2057             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2058                 xfree(aname); aname = NULL;
2059                 break;
2060             }
2061             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2062                 xfree(acomment); acomment = NULL;
2063                 break;
2064             }
2065             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2066                 xfree(amail); amail = NULL;
2067                 break;
2068             }
2069             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2070                 if( fail ) {
2071                     tty_printf(_("Please correct the error first\n"));
2072                 }
2073                 else {
2074                     xfree(aname); aname = NULL;
2075                     xfree(acomment); acomment = NULL;
2076                     xfree(amail); amail = NULL;
2077                     break;
2078                 }
2079             }
2080             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2081                 xfree(aname); aname = NULL;
2082                 xfree(acomment); acomment = NULL;
2083                 xfree(amail); amail = NULL;
2084                 xfree(uid); uid = NULL;
2085                 break;
2086             }
2087             xfree(answer);
2088         }
2089         xfree(answer);
2090         if( !amail && !acomment && !amail )
2091             break;
2092         xfree(uid); uid = NULL;
2093     }
2094     if( uid ) {
2095         char *p = native_to_utf8( uid );
2096         xfree( uid );
2097         uid = p;
2098     }
2099     return uid;
2100 }
2101
2102
2103 /*  MODE  0 - standard
2104           1 - Ask for passphrase of the card backup key.  */
2105 static DEK *
2106 do_ask_passphrase (STRING2KEY **ret_s2k, int mode, int *r_canceled)
2107 {
2108     DEK *dek = NULL;
2109     STRING2KEY *s2k;
2110     const char *errtext = NULL;
2111     const char *custdesc = NULL;
2112
2113     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
2114
2115     if (mode == 1)
2116       custdesc = _("Please enter a passphrase to protect the off-card "
2117                    "backup of the new encryption key.");
2118
2119     s2k = xmalloc_secure( sizeof *s2k );
2120     for(;;) {
2121         s2k->mode = opt.s2k_mode;
2122         s2k->hash_algo = S2K_DIGEST_ALGO;
2123         dek = passphrase_to_dek_ext (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2124                                      errtext, custdesc, NULL, r_canceled);
2125         if (!dek && *r_canceled) {
2126             xfree(dek); dek = NULL;
2127             xfree(s2k); s2k = NULL;
2128             break;
2129         }
2130         else if( !dek ) {
2131             errtext = N_("passphrase not correctly repeated; try again");
2132             tty_printf(_("%s.\n"), _(errtext));
2133         }
2134         else if( !dek->keylen ) {
2135             xfree(dek); dek = NULL;
2136             xfree(s2k); s2k = NULL;
2137             tty_printf(_(
2138             "You don't want a passphrase - this is probably a *bad* idea!\n"
2139             "I will do it anyway.  You can change your passphrase at any time,\n"
2140             "using this program with the option \"--edit-key\".\n\n"));
2141             break;
2142         }
2143         else
2144             break; /* okay */
2145     }
2146     *ret_s2k = s2k;
2147     return dek;
2148 }
2149
2150
2151 /* Basic key generation.  Here we divert to the actual generation
2152    routines based on the requested algorithm.  */
2153 static int
2154 do_create (int algo, unsigned int nbits, KBNODE pub_root,
2155            u32 timestamp, u32 expiredate, int is_subkey,
2156            char **cache_nonce_addr)
2157 {
2158   gpg_error_t err;
2159
2160   /* Fixme: The entropy collecting message should be moved to a
2161      libgcrypt progress handler.  */
2162   if (!opt.batch)
2163     tty_printf (_(
2164 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2165 "some other action (type on the keyboard, move the mouse, utilize the\n"
2166 "disks) during the prime generation; this gives the random number\n"
2167 "generator a better chance to gain enough entropy.\n") );
2168
2169   if (algo == PUBKEY_ALGO_ELGAMAL_E)
2170     err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2171                    cache_nonce_addr);
2172   else if (algo == PUBKEY_ALGO_DSA)
2173     err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
2174                    cache_nonce_addr);
2175   else if (algo == PUBKEY_ALGO_RSA)
2176     err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
2177                    cache_nonce_addr);
2178   else
2179     BUG();
2180
2181   return err;
2182 }
2183
2184
2185 /* Generate a new user id packet or return NULL if canceled.  If
2186    KEYBLOCK is not NULL the function prevents the creation of an
2187    already existing user ID.  */
2188 PKT_user_id *
2189 generate_user_id (KBNODE keyblock)
2190 {
2191   char *p;
2192   
2193   p = ask_user_id (1, keyblock);
2194   if (!p)
2195     return NULL;  /* Canceled. */
2196   return uid_from_string (p);
2197 }
2198
2199
2200 static void
2201 release_parameter_list( struct para_data_s *r )
2202 {
2203     struct para_data_s *r2;
2204
2205     for( ; r ; r = r2 ) {
2206         r2 = r->next;
2207         if( r->key == pPASSPHRASE_DEK )
2208             xfree( r->u.dek );
2209         else if( r->key == pPASSPHRASE_S2K )
2210             xfree( r->u.s2k );
2211
2212         xfree(r);
2213     }
2214 }
2215
2216 static struct para_data_s *
2217 get_parameter( struct para_data_s *para, enum para_name key )
2218 {
2219     struct para_data_s *r;
2220
2221     for( r = para; r && r->key != key; r = r->next )
2222         ;
2223     return r;
2224 }
2225
2226 static const char *
2227 get_parameter_value( struct para_data_s *para, enum para_name key )
2228 {
2229     struct para_data_s *r = get_parameter( para, key );
2230     return (r && *r->u.value)? r->u.value : NULL;
2231 }
2232
2233 static int
2234 get_parameter_algo( struct para_data_s *para, enum para_name key, 
2235                     int *r_default)
2236 {
2237   int i;
2238   struct para_data_s *r = get_parameter( para, key );
2239
2240   if (r_default)
2241     *r_default = 0;
2242
2243   if (!r)
2244     return -1;
2245
2246   if (!ascii_strcasecmp (r->u.value, "default"))
2247     {
2248       /* Note: If you change this default algo, remember to change it
2249          also in gpg.c:gpgconf_list.  */
2250       i = DEFAULT_STD_ALGO;
2251       if (r_default)
2252         *r_default = 1;
2253     }
2254   else if (digitp (r->u.value))
2255     i = atoi( r->u.value );
2256   else if (!strcmp (r->u.value, "ELG-E")
2257            || !strcmp (r->u.value, "ELG"))
2258     i = GCRY_PK_ELG_E;
2259   else
2260     i = gcry_pk_map_name (r->u.value);
2261
2262   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2263     i = 0; /* we don't want to allow generation of these algorithms */
2264   return i;
2265 }
2266
2267 /* 
2268  * Parse the usage parameter and set the keyflags.  Returns -1 on
2269  * error, 0 for no usage given or 1 for usage available.
2270  */
2271 static int
2272 parse_parameter_usage (const char *fname,
2273                        struct para_data_s *para, enum para_name key)
2274 {
2275     struct para_data_s *r = get_parameter( para, key );
2276     char *p, *pn;
2277     unsigned int use;
2278
2279     if( !r )
2280         return 0; /* none (this is an optional parameter)*/
2281     
2282     use = 0;
2283     pn = r->u.value;
2284     while ( (p = strsep (&pn, " \t,")) ) {
2285         if ( !*p)
2286             ;
2287         else if ( !ascii_strcasecmp (p, "sign") )
2288             use |= PUBKEY_USAGE_SIG;
2289         else if ( !ascii_strcasecmp (p, "encrypt") )
2290             use |= PUBKEY_USAGE_ENC;
2291         else if ( !ascii_strcasecmp (p, "auth") )
2292             use |= PUBKEY_USAGE_AUTH;
2293         else {
2294             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2295             return -1; /* error */
2296         }
2297     }
2298     r->u.usage = use;
2299     return 1;
2300 }
2301
2302 static int
2303 parse_revocation_key (const char *fname,
2304                       struct para_data_s *para, enum para_name key)
2305 {
2306   struct para_data_s *r = get_parameter( para, key );
2307   struct revocation_key revkey;
2308   char *pn;
2309   int i;
2310
2311   if( !r )
2312     return 0; /* none (this is an optional parameter) */
2313
2314   pn = r->u.value;
2315
2316   revkey.class=0x80;
2317   revkey.algid=atoi(pn);
2318   if(!revkey.algid)
2319     goto fail;
2320
2321   /* Skip to the fpr */
2322   while(*pn && *pn!=':')
2323     pn++;
2324
2325   if(*pn!=':')
2326     goto fail;
2327
2328   pn++;
2329
2330   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2331     {
2332       int c=hextobyte(pn);
2333       if(c==-1)
2334         goto fail;
2335
2336       revkey.fpr[i]=c;
2337     }
2338
2339   /* skip to the tag */
2340   while(*pn && *pn!='s' && *pn!='S')
2341     pn++;
2342
2343   if(ascii_strcasecmp(pn,"sensitive")==0)
2344     revkey.class|=0x40;
2345
2346   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2347
2348   return 0;
2349
2350   fail:
2351   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2352   return -1; /* error */
2353 }
2354
2355
2356 static u32
2357 get_parameter_u32( struct para_data_s *para, enum para_name key )
2358 {
2359   struct para_data_s *r = get_parameter( para, key );
2360
2361   if( !r )
2362     return 0;
2363   if( r->key == pKEYCREATIONDATE )
2364     return r->u.creation;
2365   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2366     return r->u.expire;
2367   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2368     return r->u.usage;
2369   
2370   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2371 }
2372
2373 static unsigned int
2374 get_parameter_uint( struct para_data_s *para, enum para_name key )
2375 {
2376     return get_parameter_u32( para, key );
2377 }
2378
2379 static struct revocation_key *
2380 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2381 {
2382     struct para_data_s *r = get_parameter( para, key );
2383     return r? &r->u.revkey : NULL;
2384 }
2385
2386 static int
2387 proc_parameter_file( struct para_data_s *para, const char *fname,
2388                      struct output_control_s *outctrl, int card )
2389 {
2390   struct para_data_s *r;
2391   const char *s1, *s2, *s3;
2392   size_t n;
2393   char *p;
2394   int is_default = 0;
2395   int have_user_id = 0;
2396   int err, algo;
2397
2398   /* Check that we have all required parameters. */
2399   r = get_parameter( para, pKEYTYPE );
2400   if(r)
2401     {
2402       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
2403       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2404         {
2405           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2406           return -1;
2407         }
2408     }
2409   else
2410     {
2411       log_error ("%s: no Key-Type specified\n",fname);
2412       return -1;
2413     }
2414
2415   err = parse_parameter_usage (fname, para, pKEYUSAGE);
2416   if (!err)
2417     {
2418       /* Default to algo capabilities if key-usage is not provided and
2419          no default algorithm has been requested.  */
2420       r = xmalloc_clear(sizeof(*r));
2421       r->key = pKEYUSAGE;
2422       r->u.usage = (is_default
2423                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
2424                     : openpgp_pk_algo_usage(algo));
2425       r->next = para;
2426       para = r;
2427     }
2428   else if (err == -1)
2429     return -1;
2430   else
2431     {
2432       r = get_parameter (para, pKEYUSAGE);
2433       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2434         {
2435           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
2436                      fname, r->lnr, algo);
2437           return -1;
2438         }
2439     }
2440
2441   is_default = 0;
2442   r = get_parameter( para, pSUBKEYTYPE );
2443   if(r)
2444     {
2445       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
2446       if (openpgp_pk_test_algo (algo))
2447         {
2448           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2449           return -1;
2450         }
2451
2452       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2453       if (!err)
2454         {
2455           /* Default to algo capabilities if subkey-usage is not
2456              provided */
2457           r = xmalloc_clear (sizeof(*r));
2458           r->key = pSUBKEYUSAGE;
2459           r->u.usage = (is_default
2460                         ? PUBKEY_USAGE_ENC
2461                         : openpgp_pk_algo_usage (algo));
2462           r->next = para;
2463           para = r;
2464         }
2465       else if (err == -1)
2466         return -1;
2467       else
2468         {
2469           r = get_parameter (para, pSUBKEYUSAGE);
2470           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2471             {
2472               log_error ("%s:%d: specified Subkey-Usage not allowed"
2473                          " for algo %d\n", fname, r->lnr, algo);
2474               return -1;
2475             }
2476         }
2477     }
2478
2479
2480   if( get_parameter_value( para, pUSERID ) )
2481     have_user_id=1;
2482   else
2483     {
2484       /* create the formatted user ID */
2485       s1 = get_parameter_value( para, pNAMEREAL );
2486       s2 = get_parameter_value( para, pNAMECOMMENT );
2487       s3 = get_parameter_value( para, pNAMEEMAIL );
2488       if( s1 || s2 || s3 )
2489         {
2490           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2491           r = xmalloc_clear( sizeof *r + n + 20 );
2492           r->key = pUSERID;
2493           p = r->u.value;
2494           if( s1 )
2495             p = stpcpy(p, s1 );
2496           if( s2 )
2497             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2498           if( s3 )
2499             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2500           r->next = para;
2501           para = r;
2502           have_user_id=1;
2503         }
2504     }
2505
2506   if(!have_user_id)
2507     {
2508       log_error("%s: no User-ID specified\n",fname);
2509       return -1;
2510     }
2511
2512   /* Set preferences, if any. */
2513   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2514
2515   /* Set keyserver, if any. */
2516   s1=get_parameter_value( para, pKEYSERVER );
2517   if(s1)
2518     {
2519       struct keyserver_spec *spec;
2520
2521       spec=parse_keyserver_uri(s1,1,NULL,0);
2522       if(spec)
2523         {
2524           free_keyserver_spec(spec);
2525           opt.def_keyserver_url=s1;
2526         }
2527       else
2528         {
2529           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
2530           return -1;
2531         }
2532     }
2533
2534   /* Set revoker, if any. */
2535   if (parse_revocation_key (fname, para, pREVOKER))
2536     return -1;
2537
2538   /* Make DEK and S2K from the Passphrase. */
2539   if (outctrl->ask_passphrase)
2540     {
2541       /* %ask-passphrase is active - ignore pPASSPRASE and ask.  This
2542          feature is required so that GUIs are able to do a key
2543          creation but have gpg-agent ask for the passphrase.  */
2544       int canceled = 0;
2545       STRING2KEY *s2k;
2546       DEK *dek;
2547
2548       dek = do_ask_passphrase (&s2k, 0, &canceled);
2549       if (dek)
2550         {
2551           r = xmalloc_clear( sizeof *r );
2552           r->key = pPASSPHRASE_DEK;
2553           r->u.dek = dek;
2554           r->next = para;
2555           para = r;
2556           r = xmalloc_clear( sizeof *r );
2557           r->key = pPASSPHRASE_S2K;
2558           r->u.s2k = s2k;
2559           r->next = para;
2560           para = r;
2561         }
2562
2563       if (canceled) 
2564         {
2565           log_error ("%s:%d: key generation canceled\n", fname, r->lnr );
2566           return -1;
2567         }
2568     }
2569   else
2570     {
2571       r = get_parameter( para, pPASSPHRASE );
2572       if ( r && *r->u.value )
2573         {
2574           /* We have a plain text passphrase - create a DEK from it.
2575            * It is a little bit ridiculous to keep it in secure memory
2576            * but because we do this always, why not here.  */
2577           STRING2KEY *s2k;
2578           DEK *dek;
2579           
2580           s2k = xmalloc_secure ( sizeof *s2k );
2581           s2k->mode = opt.s2k_mode;
2582           s2k->hash_algo = S2K_DIGEST_ALGO;
2583           set_next_passphrase ( r->u.value );
2584           dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2585                                    NULL, NULL);
2586           set_next_passphrase (NULL );
2587           assert (dek);
2588           memset (r->u.value, 0, strlen(r->u.value));
2589           
2590           r = xmalloc_clear (sizeof *r);
2591           r->key = pPASSPHRASE_S2K;
2592           r->u.s2k = s2k;
2593           r->next = para;
2594           para = r;
2595           r = xmalloc_clear (sizeof *r);
2596           r->key = pPASSPHRASE_DEK;
2597           r->u.dek = dek;
2598           r->next = para;
2599           para = r;
2600         }
2601     }
2602
2603   /* Make KEYCREATIONDATE from Creation-Date.  */
2604   r = get_parameter (para, pCREATIONDATE);
2605   if (r && *r->u.value)
2606     {
2607       u32 seconds;
2608
2609       seconds = parse_creation_string (r->u.value);
2610       if (!seconds)
2611         {
2612           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
2613           return -1;
2614         }
2615       r->u.creation = seconds;
2616       r->key = pKEYCREATIONDATE;  /* Change that entry. */
2617     }
2618
2619   /* Make KEYEXPIRE from Expire-Date.  */
2620   r = get_parameter( para, pEXPIREDATE );
2621   if( r && *r->u.value )
2622     {
2623       u32 seconds;
2624
2625       seconds = parse_expire_string( r->u.value );
2626       if( seconds == (u32)-1 )
2627         {
2628           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2629           return -1;
2630         }
2631       r->u.expire = seconds;
2632       r->key = pKEYEXPIRE;  /* change hat entry */
2633       /* also set it for the subkey */
2634       r = xmalloc_clear( sizeof *r + 20 );
2635       r->key = pSUBKEYEXPIRE;
2636       r->u.expire = seconds;
2637       r->next = para;
2638       para = r;
2639     }
2640
2641   if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2642     log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2643     return -1;
2644   }
2645
2646   do_generate_keypair( para, outctrl, card );
2647   return 0;
2648 }
2649
2650
2651 /****************
2652  * Kludge to allow non interactive key generation controlled
2653  * by a parameter file.
2654  * Note, that string parameters are expected to be in UTF-8
2655  */
2656 static void
2657 read_parameter_file( const char *fname )
2658 {
2659     static struct { const char *name;
2660                     enum para_name key;
2661     } keywords[] = {
2662         { "Key-Type",       pKEYTYPE},
2663         { "Key-Length",     pKEYLENGTH },
2664         { "Key-Usage",      pKEYUSAGE },
2665         { "Subkey-Type",    pSUBKEYTYPE },
2666         { "Subkey-Length",  pSUBKEYLENGTH },
2667         { "Subkey-Usage",   pSUBKEYUSAGE },
2668         { "Name-Real",      pNAMEREAL },
2669         { "Name-Email",     pNAMEEMAIL },
2670         { "Name-Comment",   pNAMECOMMENT },
2671         { "Expire-Date",    pEXPIREDATE },
2672         { "Creation-Date",  pCREATIONDATE },
2673         { "Passphrase",     pPASSPHRASE },
2674         { "Preferences",    pPREFERENCES },
2675         { "Revoker",        pREVOKER },
2676         { "Handle",         pHANDLE },
2677         { "Keyserver",      pKEYSERVER },
2678         { NULL, 0 }
2679     };
2680     IOBUF fp;
2681     byte *line;
2682     unsigned int maxlen, nline;
2683     char *p;
2684     int lnr;
2685     const char *err = NULL;
2686     struct para_data_s *para, *r;
2687     int i;
2688     struct output_control_s outctrl;
2689
2690     memset( &outctrl, 0, sizeof( outctrl ) );
2691     outctrl.pub.afx = new_armor_context ();
2692     outctrl.sec.afx = new_armor_context ();
2693
2694     if( !fname || !*fname)
2695       fname = "-";
2696
2697     fp = iobuf_open (fname);
2698     if (fp && is_secured_file (iobuf_get_fd (fp)))
2699       {
2700         iobuf_close (fp);
2701         fp = NULL;
2702         gpg_err_set_errno (EPERM);
2703       }
2704     if (!fp) {
2705       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2706       return;
2707     }
2708     iobuf_ioctl (fp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
2709
2710     lnr = 0;
2711     err = NULL;
2712     para = NULL;
2713     maxlen = 1024;
2714     line = NULL;
2715     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2716         char *keyword, *value;
2717
2718         lnr++;
2719         if( !maxlen ) {
2720             err = "line too long";
2721             break;
2722         }
2723         for( p = line; isspace(*(byte*)p); p++ )
2724             ;
2725         if( !*p || *p == '#' )
2726             continue;
2727         keyword = p;
2728         if( *keyword == '%' ) {
2729             for( ; !isspace(*(byte*)p); p++ )
2730                 ;
2731             if( *p )
2732                 *p++ = 0;
2733             for( ; isspace(*(byte*)p); p++ )
2734                 ;
2735             value = p;
2736             trim_trailing_ws( value, strlen(value) );
2737             if( !ascii_strcasecmp( keyword, "%echo" ) )
2738                 log_info("%s\n", value );
2739             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2740                 outctrl.dryrun = 1;
2741             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
2742                 outctrl.ask_passphrase = 1;
2743             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
2744                 outctrl.ask_passphrase = 0;
2745             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2746                 outctrl.lnr = lnr;
2747                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2748                   print_status_key_not_created 
2749                     (get_parameter_value (para, pHANDLE));
2750                 release_parameter_list( para );
2751                 para = NULL;
2752             }
2753             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2754                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2755                     ; /* still the same file - ignore it */
2756                 else {
2757                     xfree( outctrl.pub.newfname );
2758                     outctrl.pub.newfname = xstrdup( value );
2759                     outctrl.use_files = 1;
2760                 }
2761             }
2762             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2763                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2764                     ; /* still the same file - ignore it */
2765                 else {
2766                    xfree( outctrl.sec.newfname );
2767                    outctrl.sec.newfname = xstrdup( value );
2768                    outctrl.use_files = 1;
2769                 }
2770             }
2771             else
2772                 log_info("skipping control `%s' (%s)\n", keyword, value );
2773
2774
2775             continue;
2776         }
2777
2778
2779         if( !(p = strchr( p, ':' )) || p == keyword ) {
2780             err = "missing colon";
2781             break;
2782         }
2783         if( *p )
2784             *p++ = 0;
2785         for( ; isspace(*(byte*)p); p++ )
2786             ;
2787         if( !*p ) {
2788             err = "missing argument";
2789             break;
2790         }
2791         value = p;
2792         trim_trailing_ws( value, strlen(value) );
2793
2794         for(i=0; keywords[i].name; i++ ) {
2795             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2796                 break;
2797         }
2798         if( !keywords[i].name ) {
2799             err = "unknown keyword";
2800             break;
2801         }
2802         if( keywords[i].key != pKEYTYPE && !para ) {
2803             err = "parameter block does not start with \"Key-Type\"";
2804             break;
2805         }
2806
2807         if( keywords[i].key == pKEYTYPE && para ) {
2808             outctrl.lnr = lnr;
2809             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2810               print_status_key_not_created
2811                 (get_parameter_value (para, pHANDLE));
2812             release_parameter_list( para );
2813             para = NULL;
2814         }
2815         else {
2816             for( r = para; r; r = r->next ) {
2817                 if( r->key == keywords[i].key )
2818                     break;
2819             }
2820             if( r ) {
2821                 err = "duplicate keyword";
2822                 break;
2823             }
2824         }
2825         r = xmalloc_clear( sizeof *r + strlen( value ) );
2826         r->lnr = lnr;
2827         r->key = keywords[i].key;
2828         strcpy( r->u.value, value );
2829         r->next = para;
2830         para = r;
2831     }
2832     if( err )
2833         log_error("%s:%d: %s\n", fname, lnr, err );
2834     else if( iobuf_error (fp) ) {
2835         log_error("%s:%d: read error\n", fname, lnr);
2836     }
2837     else if( para ) {
2838         outctrl.lnr = lnr;
2839         if (proc_parameter_file( para, fname, &outctrl, 0 ))
2840           print_status_key_not_created (get_parameter_value (para, pHANDLE));
2841     }
2842
2843     if( outctrl.use_files ) { /* close open streams */
2844         iobuf_close( outctrl.pub.stream );
2845         iobuf_close( outctrl.sec.stream );
2846
2847         /* Must invalidate that ugly cache to actually close it.  */
2848         if (outctrl.pub.fname)
2849           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 
2850                        0, (char*)outctrl.pub.fname);
2851         if (outctrl.sec.fname)
2852           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
2853                        0, (char*)outctrl.sec.fname);
2854
2855         xfree( outctrl.pub.fname );
2856         xfree( outctrl.pub.newfname );
2857         xfree( outctrl.sec.fname );
2858         xfree( outctrl.sec.newfname );
2859     }
2860
2861     release_parameter_list( para );
2862     iobuf_close (fp);
2863     release_armor_context (outctrl.pub.afx);
2864     release_armor_context (outctrl.sec.afx);
2865 }
2866
2867
2868 /*
2869  * Generate a keypair (fname is only used in batch mode) If
2870  * CARD_SERIALNO is not NULL the function will create the keys on an
2871  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
2872  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
2873  * generate in software, imported to the card and a backup file
2874  * written to directory given by this argument .
2875  */
2876 void
2877 generate_keypair (const char *fname, const char *card_serialno, 
2878                   const char *backup_encryption_dir)
2879 {
2880   unsigned int nbits;
2881   char *uid = NULL;
2882   int algo;
2883   unsigned int use;
2884   int both = 0;
2885   u32 expire;
2886   struct para_data_s *para = NULL;
2887   struct para_data_s *r;
2888   struct output_control_s outctrl;
2889   
2890   memset( &outctrl, 0, sizeof( outctrl ) );
2891   
2892   if (opt.batch && card_serialno)
2893     {
2894       /* We don't yet support unattended key generation. */
2895       log_error (_("can't do this in batch mode\n"));
2896       return;
2897     }
2898   
2899   if (opt.batch)
2900     {
2901       read_parameter_file( fname );
2902       return;
2903     }
2904
2905   if (card_serialno)
2906     {
2907 #ifdef ENABLE_CARD_SUPPORT
2908       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2909       r->key = pSERIALNO;
2910       strcpy( r->u.value, card_serialno);
2911       r->next = para;
2912       para = r;
2913        
2914       algo = PUBKEY_ALGO_RSA;
2915        
2916       r = xcalloc (1, sizeof *r + 20 );
2917       r->key = pKEYTYPE;
2918       sprintf( r->u.value, "%d", algo );
2919       r->next = para;
2920       para = r;
2921       r = xcalloc (1, sizeof *r + 20 );
2922       r->key = pKEYUSAGE;
2923       strcpy (r->u.value, "sign");
2924       r->next = para;
2925       para = r;
2926        
2927       r = xcalloc (1, sizeof *r + 20 );
2928       r->key = pSUBKEYTYPE;
2929       sprintf( r->u.value, "%d", algo );
2930       r->next = para;
2931       para = r;
2932       r = xcalloc (1, sizeof *r + 20 );
2933       r->key = pSUBKEYUSAGE;
2934       strcpy (r->u.value, "encrypt");
2935       r->next = para;
2936       para = r;
2937        
2938       r = xcalloc (1, sizeof *r + 20 );
2939       r->key = pAUTHKEYTYPE;
2940       sprintf( r->u.value, "%d", algo );
2941       r->next = para;
2942       para = r;
2943
2944       if (backup_encryption_dir)
2945         {
2946           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
2947           r->key = pBACKUPENCDIR;
2948           strcpy (r->u.value, backup_encryption_dir);
2949           r->next = para;
2950           para = r;
2951         }
2952 #endif /*ENABLE_CARD_SUPPORT*/
2953     }
2954   else
2955     {
2956       int subkey_algo; 
2957
2958       algo = ask_algo (0, &subkey_algo, &use);
2959       if (subkey_algo)
2960         { 
2961           /* Create primary and subkey at once.  */
2962           both = 1;
2963           r = xmalloc_clear( sizeof *r + 20 );
2964           r->key = pKEYTYPE;
2965           sprintf( r->u.value, "%d", algo );
2966           r->next = para;
2967           para = r;
2968           nbits = ask_keysize (algo, 0);
2969           r = xmalloc_clear( sizeof *r + 20 );
2970           r->key = pKEYLENGTH;
2971           sprintf( r->u.value, "%u", nbits);
2972           r->next = para;
2973           para = r;
2974           r = xmalloc_clear( sizeof *r + 20 );
2975           r->key = pKEYUSAGE;
2976           strcpy( r->u.value, "sign" );
2977           r->next = para;
2978           para = r;
2979            
2980           r = xmalloc_clear( sizeof *r + 20 );
2981           r->key = pSUBKEYTYPE;
2982           sprintf( r->u.value, "%d", subkey_algo);
2983           r->next = para;
2984           para = r;
2985           r = xmalloc_clear( sizeof *r + 20 );
2986           r->key = pSUBKEYUSAGE;
2987           strcpy( r->u.value, "encrypt" );
2988           r->next = para;
2989           para = r;
2990         }
2991       else 
2992         {
2993           r = xmalloc_clear( sizeof *r + 20 );
2994           r->key = pKEYTYPE;
2995           sprintf( r->u.value, "%d", algo );
2996           r->next = para;
2997           para = r;
2998            
2999           if (use)
3000             {
3001               r = xmalloc_clear( sizeof *r + 25 );
3002               r->key = pKEYUSAGE;
3003               sprintf( r->u.value, "%s%s%s",
3004                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
3005                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
3006                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
3007               r->next = para;
3008               para = r;
3009             }
3010           nbits = 0;
3011         }
3012
3013       nbits = ask_keysize (both? subkey_algo : algo, nbits);
3014       r = xmalloc_clear( sizeof *r + 20 );
3015       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
3016       sprintf( r->u.value, "%u", nbits);
3017       r->next = para;
3018       para = r;
3019     }
3020    
3021   expire = ask_expire_interval(0,NULL);
3022   r = xmalloc_clear( sizeof *r + 20 );
3023   r->key = pKEYEXPIRE;
3024   r->u.expire = expire;
3025   r->next = para;
3026   para = r;
3027   r = xmalloc_clear( sizeof *r + 20 );
3028   r->key = pSUBKEYEXPIRE;
3029   r->u.expire = expire;
3030   r->next = para;
3031   para = r;
3032
3033   uid = ask_user_id (0, NULL);
3034   if( !uid ) 
3035     {
3036       log_error(_("Key generation canceled.\n"));
3037       release_parameter_list( para );
3038       return;
3039     }
3040   r = xmalloc_clear( sizeof *r + strlen(uid) );
3041   r->key = pUSERID;
3042   strcpy( r->u.value, uid );
3043   r->next = para;
3044   para = r;
3045     
3046   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
3047   release_parameter_list( para );
3048 }
3049
3050
3051 #ifdef ENABLE_CARD_SUPPORT
3052 /* Generate a raw key and return it as a secret key packet.  The
3053    function will ask for the passphrase and return a protected as well
3054    as an unprotected copy of a new secret key packet.  0 is returned
3055    on success and the caller must then free the returned values.  */
3056 static int
3057 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
3058                   PKT_secret_key **r_sk_unprotected,
3059                   PKT_secret_key **r_sk_protected)
3060 {
3061   int rc;
3062   DEK *dek = NULL;
3063   STRING2KEY *s2k = NULL;
3064   PKT_secret_key *sk = NULL;
3065   int i;
3066   size_t nskey, npkey;
3067   gcry_sexp_t s_parms, s_key;
3068   int canceled;
3069
3070   npkey = pubkey_get_npkey (algo);
3071   nskey = pubkey_get_nskey (algo);
3072   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
3073
3074   if (nbits < 512)
3075     {
3076       nbits = 512;
3077       log_info (_("keysize invalid; using %u bits\n"), nbits );
3078     }
3079
3080   if ((nbits % 32)) 
3081     {
3082       nbits = ((nbits + 31) / 32) * 32;
3083       log_info(_("keysize rounded up to %u bits\n"), nbits );
3084     }
3085
3086   dek = do_ask_passphrase (&s2k, 1, &canceled);
3087   if (canceled)
3088     {
3089       rc = gpg_error (GPG_ERR_CANCELED);
3090       goto leave;
3091     }
3092
3093   sk = xmalloc_clear (sizeof *sk);
3094   sk->timestamp = created_at;
3095   sk->version = 4;
3096   sk->pubkey_algo = algo;
3097
3098   if ( !is_RSA (algo) )
3099     {
3100       log_error ("only RSA is supported for offline generated keys\n");
3101       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3102       goto leave;
3103     }
3104   rc = gcry_sexp_build (&s_parms, NULL,
3105                         "(genkey(rsa(nbits %d)))",
3106                         (int)nbits);
3107   if (rc)
3108     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
3109   rc = gcry_pk_genkey (&s_key, s_parms);
3110   gcry_sexp_release (s_parms);
3111   if (rc)
3112     {
3113       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
3114       goto leave;
3115     }
3116   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
3117   gcry_sexp_release (s_key);
3118   if (rc) 
3119     {
3120       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
3121       goto leave;
3122     }
3123   
3124   for (i=npkey; i < nskey; i++)
3125     sk->csum += checksum_mpi (sk->skey[i]);
3126
3127   if (r_sk_unprotected) 
3128     *r_sk_unprotected = copy_secret_key (NULL, sk);
3129
3130   rc = genhelp_protect (dek, s2k, sk);
3131   if (rc)
3132     goto leave;
3133
3134   if (r_sk_protected)
3135     {
3136       *r_sk_protected = sk;
3137       sk = NULL;
3138     }
3139
3140  leave:
3141   if (sk)
3142     free_secret_key (sk);
3143   xfree (dek);
3144   xfree (s2k);
3145   return rc;
3146 }
3147 #endif /* ENABLE_CARD_SUPPORT */
3148
3149 /* Create and delete a dummy packet to start off a list of kbnodes. */
3150 static void
3151 start_tree(KBNODE *tree)
3152 {
3153   PACKET *pkt;
3154
3155   pkt=xmalloc_clear(sizeof(*pkt));
3156   pkt->pkttype=PKT_NONE;
3157   *tree=new_kbnode(pkt);
3158   delete_kbnode(*tree);
3159 }
3160
3161
3162 static void
3163 do_generate_keypair (struct para_data_s *para,
3164                      struct output_control_s *outctrl, int card)
3165 {
3166   gpg_error_t err;
3167   KBNODE pub_root = NULL;
3168   const char *s;
3169   PKT_public_key *pri_psk = NULL;
3170   PKT_public_key *sub_psk = NULL;
3171   struct revocation_key *revkey;
3172   int did_sub = 0;
3173   u32 timestamp;
3174   char *cache_nonce = NULL;
3175
3176   if (outctrl->dryrun)
3177     {
3178       log_info("dry-run mode - key generation skipped\n");
3179       return;
3180     }
3181   
3182   if ( outctrl->use_files ) 
3183     {
3184       if ( outctrl->pub.newfname ) 
3185         {
3186           iobuf_close(outctrl->pub.stream);
3187           outctrl->pub.stream = NULL;
3188           if (outctrl->pub.fname)
3189             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
3190                          0, (char*)outctrl->pub.fname);
3191           xfree( outctrl->pub.fname );
3192           outctrl->pub.fname =  outctrl->pub.newfname;
3193           outctrl->pub.newfname = NULL;
3194           
3195           if (is_secured_filename (outctrl->pub.fname) ) 
3196             {
3197               outctrl->pub.stream = NULL;
3198               gpg_err_set_errno (EPERM);
3199             }
3200           else
3201             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
3202           if (!outctrl->pub.stream)
3203             {
3204               log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
3205                         strerror(errno) );
3206               return;
3207             }
3208           if (opt.armor)
3209             {
3210               outctrl->pub.afx->what = 1;
3211               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
3212             }
3213         }
3214       assert( outctrl->pub.stream );
3215       if (opt.verbose)
3216         log_info (_("writing public key to `%s'\n"), outctrl->pub.fname );
3217     }
3218
3219
3220   /* We create the packets as a tree of kbnodes.  Because the
3221      structure we create is known in advance we simply generate a
3222      linked list.  The first packet is a dummy packet which we flag as
3223      deleted.  The very first packet must always be a KEY packet.  */
3224     
3225   start_tree (&pub_root);
3226
3227   timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
3228   if (!timestamp)
3229     timestamp = make_timestamp ();
3230
3231   /* Note that, depending on the backend (i.e. the used scdaemon
3232      version), the card key generation may update TIMESTAMP for each
3233      key.  Thus we need to pass TIMESTAMP to all signing function to
3234      make sure that the binding signature is done using the timestamp
3235      of the corresponding (sub)key and not that of the primary key.
3236      An alternative implementation could tell the signing function the
3237      node of the subkey but that is more work than just to pass the
3238      current timestamp.  */
3239
3240   if (!card)
3241     err = do_create (get_parameter_algo( para, pKEYTYPE, NULL ),
3242                      get_parameter_uint( para, pKEYLENGTH ),
3243                      pub_root,
3244                      timestamp,
3245                      get_parameter_u32( para, pKEYEXPIRE ), 0, &cache_nonce);
3246   else
3247     err = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root,
3248                         &timestamp,
3249                         get_parameter_u32 (para, pKEYEXPIRE), para);
3250
3251   /* Get the pointer to the generated public key packet.  */
3252   if (!err)
3253     {
3254       pri_psk = pub_root->next->pkt->pkt.public_key;
3255       assert (pri_psk);
3256     }
3257
3258   if (!err && (revkey = get_parameter_revkey (para, pREVOKER)))
3259     err = write_direct_sig (pub_root, pri_psk, revkey, timestamp, cache_nonce);
3260
3261   if (!err && (s = get_parameter_value (para, pUSERID)))
3262     {
3263       write_uid (pub_root, s );
3264       err = write_selfsigs (pub_root, pri_psk,
3265                             get_parameter_uint (para, pKEYUSAGE), timestamp,
3266                             cache_nonce);
3267     }
3268
3269   /* Write the auth key to the card before the encryption key.  This
3270      is a partial workaround for a PGP bug (as of this writing, all
3271      versions including 8.1), that causes it to try and encrypt to
3272      the most recent subkey regardless of whether that subkey is
3273      actually an encryption type.  In this case, the auth key is an
3274      RSA key so it succeeds. */
3275
3276   if (!err && card && get_parameter (para, pAUTHKEYTYPE))
3277     {
3278       err = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root,
3279                           &timestamp,
3280                           get_parameter_u32 (para, pKEYEXPIRE), para);
3281       if (!err)
3282         err = write_keybinding (pub_root, pri_psk, NULL,
3283                                 PUBKEY_USAGE_AUTH, timestamp, cache_nonce);
3284     }
3285
3286   if (!err && get_parameter (para, pSUBKEYTYPE))
3287     {
3288       sub_psk = NULL;
3289       if (!card)
3290         {
3291           err = do_create (get_parameter_algo (para, pSUBKEYTYPE, NULL),
3292                            get_parameter_uint (para, pSUBKEYLENGTH),
3293                            pub_root, 
3294                            timestamp,
3295                            get_parameter_u32 (para, pSUBKEYEXPIRE), 1,
3296                            &cache_nonce);
3297           /* Get the pointer to the generated public subkey packet.  */
3298           if (!err)
3299             {
3300               kbnode_t node;
3301               
3302               for (node = pub_root; node; node = node->next)
3303                 if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3304                   sub_psk = node->pkt->pkt.public_key;
3305               assert (sub_psk);
3306             }
3307         }
3308       else
3309         {
3310           if ((s = get_parameter_value (para, pBACKUPENCDIR)))
3311             {
3312               /* A backup of the encryption key has been requested.
3313                  Generate the key in software and import it then to
3314                  the card.  Write a backup file. */
3315               err = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
3316                                               pub_root,
3317                                               timestamp,
3318                                               get_parameter_u32 (para,
3319                                                                  pKEYEXPIRE),
3320                                               para, s);
3321             }
3322           else
3323             {
3324               err = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root,
3325                                   &timestamp,
3326                                   get_parameter_u32 (para, pKEYEXPIRE), para);
3327             }
3328         }
3329
3330       if (!err)
3331         err = write_keybinding (pub_root, pri_psk, sub_psk,
3332                                 get_parameter_uint (para, pSUBKEYUSAGE),
3333                                 timestamp, cache_nonce);
3334       did_sub = 1;
3335     }
3336
3337   if (!err && outctrl->use_files)  /* Direct write to specified files.  */
3338     {
3339       err = write_keyblock (outctrl->pub.stream, pub_root);
3340       if (err)
3341         log_error ("can't write public key: %s\n", g10_errstr (err));
3342     }
3343   else if (!err) /* Write to the standard keyrings.  */
3344     {
3345       KEYDB_HANDLE pub_hd = keydb_new ();
3346
3347       err = keydb_locate_writable (pub_hd, NULL);
3348       if (err) 
3349         log_error (_("no writable public keyring found: %s\n"),
3350                    g10_errstr (err));
3351       
3352       if (!err && opt.verbose)
3353         {
3354           log_info (_("writing public key to `%s'\n"),
3355                     keydb_get_resource_name (pub_hd));
3356         }
3357       
3358       if (!err) 
3359         {
3360           err = keydb_insert_keyblock (pub_hd, pub_root);
3361           if (err)
3362             log_error (_("error writing public keyring `%s': %s\n"),
3363                        keydb_get_resource_name (pub_hd), g10_errstr(err));
3364         }
3365       
3366       keydb_release (pub_hd);
3367       
3368       if (!err)
3369         {
3370           int no_enc_rsa;
3371           PKT_public_key *pk;
3372
3373           no_enc_rsa = ((get_parameter_algo (para, pKEYTYPE, NULL)
3374                          == PUBKEY_ALGO_RSA)
3375                         && get_parameter_uint (para, pKEYUSAGE)
3376                         && !((get_parameter_uint (para, pKEYUSAGE)
3377                               & PUBKEY_USAGE_ENC)) );
3378
3379           pk = find_kbnode (pub_root, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3380
3381           keyid_from_pk (pk, pk->main_keyid);
3382           register_trusted_keyid (pk->main_keyid);
3383
3384           update_ownertrust (pk, ((get_ownertrust (pk) & ~TRUST_MASK)
3385                                   | TRUST_ULTIMATE ));
3386
3387           if (!opt.batch) 
3388             {
3389               tty_printf (_("public and secret key created and signed.\n") );
3390               tty_printf ("\n");
3391               list_keyblock (pub_root, 0, 1, NULL);
3392             }
3393             
3394           
3395           if (!opt.batch
3396               && (get_parameter_algo (para, pKEYTYPE, NULL) == PUBKEY_ALGO_DSA
3397                   || no_enc_rsa )
3398               && !get_parameter (para, pSUBKEYTYPE) )
3399             {
3400               tty_printf(_("Note that this key cannot be used for "
3401                            "encryption.  You may want to use\n"
3402                            "the command \"--edit-key\" to generate a "
3403                            "subkey for this purpose.\n") );
3404             }
3405         }
3406     }
3407
3408   if (err)
3409     {
3410       if (opt.batch)
3411         log_error ("key generation failed: %s\n", g10_errstr(err) );
3412       else
3413         tty_printf (_("Key generation failed: %s\n"), g10_errstr(err) );
3414       write_status_error (card? "card_key_generate":"key_generate", err);
3415       print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
3416     }
3417   else
3418     {
3419       PKT_public_key *pk = find_kbnode (pub_root, 
3420                                         PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3421       print_status_key_created (did_sub? 'B':'P', pk,
3422                                 get_parameter_value (para, pHANDLE));
3423     }
3424   
3425   release_kbnode (pub_root);
3426   xfree (cache_nonce);
3427 }
3428
3429
3430 /* Add a new subkey to an existing key.  Returns 0 if a new key has
3431    been generated and put into the keyblocks.  */
3432 gpg_error_t
3433 generate_subkeypair (KBNODE keyblock)
3434 {
3435   gpg_error_t err = 0;
3436   kbnode_t node;
3437   PKT_public_key *pri_psk = NULL;
3438   PKT_public_key *sub_psk = NULL;
3439   int algo;
3440   unsigned int use;
3441   u32 expire;
3442   unsigned int nbits;
3443   u32 cur_time;
3444
3445   /* Break out the primary key.  */
3446   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
3447   if (!node) 
3448     {
3449       log_error ("Oops; primary key missing in keyblock!\n");
3450       err = gpg_error (GPG_ERR_BUG);
3451       goto leave;
3452     }
3453   pri_psk = node->pkt->pkt.public_key;
3454
3455   cur_time = make_timestamp ();
3456
3457   if (pri_psk->timestamp > cur_time)
3458     {
3459       ulong d = pri_psk->timestamp - cur_time;
3460       log_info ( d==1 ? _("key has been created %lu second "
3461                           "in future (time warp or clock problem)\n")
3462                  : _("key has been created %lu seconds "
3463                      "in future (time warp or clock problem)\n"), d );
3464       if (!opt.ignore_time_conflict)
3465         {
3466           err = gpg_error (GPG_ERR_TIME_CONFLICT);
3467           goto leave;
3468         }
3469     }
3470
3471   if (pri_psk->version < 4) 
3472     {
3473       log_info (_("NOTE: creating subkeys for v3 keys "
3474                   "is not OpenPGP compliant\n"));
3475       err = gpg_error (GPG_ERR_CONFLICT);
3476       goto leave;
3477     }
3478
3479 #warning ask gpg-agent on the availibility of the secret key
3480   /* if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001) */
3481   /*   { */
3482   /*     tty_printf (_("Secret parts of primary key are not available.\n")); */
3483   /*     err = G10ERR_NO_SECKEY; */
3484   /*     goto leave; */
3485   /*   } */
3486
3487
3488   /* /\* Unprotect to get the passphrase.  *\/ */
3489   /* switch (is_secret_key_protected (pri_sk) ) */
3490   /*   { */
3491   /*   case -1: */
3492   /*     err = G10ERR_PUBKEY_ALGO; */
3493   /*     break; */
3494   /*   case 0: */
3495   /*     tty_printf (_("This key is not protected.\n")); */
3496   /*     break; */
3497   /*   case -2: */
3498   /*     tty_printf (_("Secret parts of primary key are stored on-card.\n")); */
3499   /*     ask_pass = 1; */
3500   /*     break; */
3501   /*   default: */
3502   /*     tty_printf (_("Key is protected.\n")); */
3503   /*     err = check_secret_key ( pri_sk, 0 ); */
3504   /*     if (!err) */
3505   /*       passphrase = get_last_passphrase(); */
3506   /*     break; */
3507   /*   } */
3508   /* if (err) */
3509   /*   goto leave; */
3510
3511   algo = ask_algo (1, NULL, &use);
3512   assert (algo);
3513   nbits = ask_keysize (algo, 0);
3514   expire = ask_expire_interval (0, NULL);
3515   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3516                                                _("Really create? (y/N) ")))
3517     {
3518       err = gpg_error (GPG_ERR_CANCELED);
3519       goto leave;
3520     }  
3521
3522   err = do_create (algo, nbits, keyblock, cur_time, expire, 1, NULL);
3523   if (err)
3524     goto leave;
3525
3526   /* Get the pointer to the generated public subkey packet.  */
3527   for (node = keyblock; node; node = node->next)
3528     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3529       sub_psk = node->pkt->pkt.public_key;
3530
3531   /* Write the binding signature.  */
3532   err = write_keybinding (keyblock, pri_psk, sub_psk, use, cur_time, NULL);
3533   if (err)
3534     goto leave;
3535
3536   write_status_text (STATUS_KEY_CREATED, "S");
3537
3538  leave:
3539   if (err)
3540     log_error (_("Key generation failed: %s\n"), g10_errstr (err) );
3541   return err;
3542 }
3543
3544
3545 #ifdef ENABLE_CARD_SUPPORT
3546 /* Generate a subkey on a card. */
3547 int
3548 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3549                           int keyno, const char *serialno)
3550 {
3551   gpg_error_t err = 0;
3552   int okay = 0;
3553   kbnode_t node;
3554   PKT_secret_key *pri_sk = NULL, *sub_sk;
3555   int algo;
3556   unsigned int use;
3557   u32 expire;
3558   char *passphrase = NULL;
3559   u32 cur_time;
3560   struct para_data_s *para = NULL;
3561
3562   assert (keyno >= 1 && keyno <= 3);
3563
3564   para = xcalloc (1, sizeof *para + strlen (serialno) );
3565   para->key = pSERIALNO;
3566   strcpy (para->u.value, serialno);
3567
3568   /* Break out the primary secret key */
3569   node = find_kbnode (sec_keyblock, PKT_SECRET_KEY);
3570   if (!node)
3571     {
3572       log_error("Oops; secret key not found anymore!\n");
3573       goto leave;
3574     }
3575
3576   /* Make a copy of the sk to keep the protected one in the keyblock */
3577   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3578
3579   cur_time = make_timestamp();
3580   if (pri_sk->timestamp > cur_time)
3581     {
3582       ulong d = pri_sk->timestamp - cur_time;
3583       log_info (d==1 ? _("key has been created %lu second "
3584                          "in future (time warp or clock problem)\n")
3585                      : _("key has been created %lu seconds "
3586                          "in future (time warp or clock problem)\n"), d );
3587         if (!opt.ignore_time_conflict)
3588           {
3589             err = G10ERR_TIME_CONFLICT;
3590             goto leave;
3591           }
3592     }
3593
3594   if (pri_sk->version < 4)
3595     {
3596       log_info (_("NOTE: creating subkeys for v3 keys "
3597                   "is not OpenPGP compliant\n"));
3598       goto leave;
3599     }
3600
3601   /* Unprotect to get the passphrase. */
3602   switch( is_secret_key_protected (pri_sk) )
3603     {
3604     case -1:
3605       err = G10ERR_PUBKEY_ALGO;
3606       break;
3607     case 0:
3608       tty_printf("This key is not protected.\n");
3609       break;
3610     default:
3611       tty_printf("Key is protected.\n");
3612       err = check_secret_key( pri_sk, 0 );
3613       if (!err)
3614         passphrase = get_last_passphrase();
3615       break;
3616     }
3617   if (err)
3618     goto leave;
3619
3620   algo = PUBKEY_ALGO_RSA;
3621   expire = ask_expire_interval (0,NULL);
3622   if (keyno == 1)
3623     use = PUBKEY_USAGE_SIG;
3624   else if (keyno == 2)
3625     use = PUBKEY_USAGE_ENC;
3626   else
3627     use = PUBKEY_USAGE_AUTH;
3628   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3629                                                _("Really create? (y/N) ")))
3630     goto leave;
3631
3632   if (passphrase)
3633     set_next_passphrase (passphrase);
3634
3635   /* Note, that depending on the backend, the card key generation may
3636      update CUR_TIME.  */
3637   err = gen_card_key (algo, keyno, 0, pub_keyblock, &cur_time, expire, para);
3638   if (!err)
3639     err = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, sub_sk, 
3640                             use, cur_time);
3641   if (!err)
3642     err = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, sub_sk, 
3643                            use, cur_time);
3644   if (!err)
3645     {
3646       okay = 1;
3647       write_status_text (STATUS_KEY_CREATED, "S");
3648     }
3649
3650  leave:
3651   if (err)
3652     log_error (_("Key generation failed: %s\n"), g10_errstr(err) );
3653   xfree (passphrase);
3654   /* Release the copy of the (now unprotected) secret keys. */
3655   if (pri_sk)
3656     free_secret_key (pri_sk);
3657   set_next_passphrase( NULL );
3658   release_parameter_list (para);
3659   return okay;
3660 }
3661 #endif /* !ENABLE_CARD_SUPPORT */
3662
3663
3664 /*
3665  * Write a keyblock to an output stream
3666  */
3667 static int
3668 write_keyblock( IOBUF out, KBNODE node )
3669 {
3670   for( ; node ; node = node->next )
3671     {
3672       if(!is_deleted_kbnode(node))
3673         {
3674           int rc = build_packet( out, node->pkt );
3675           if( rc )
3676             {
3677               log_error("build_packet(%d) failed: %s\n",
3678                         node->pkt->pkttype, g10_errstr(rc) );
3679               return rc;
3680             }
3681         }
3682     }
3683
3684   return 0;
3685 }
3686
3687
3688 /* Note that timestamp is an in/out arg. */
3689 static int
3690 gen_card_key (int algo, int keyno, int is_primary, KBNODE pub_root, 
3691               u32 *timestamp, u32 expireval, struct para_data_s *para)
3692 {
3693 #ifdef ENABLE_CARD_SUPPORT
3694   int rc;
3695   const char *s;
3696   struct agent_card_genkey_s info;
3697   PACKET *pkt;
3698   PKT_secret_key *sk;
3699   PKT_public_key *pk;
3700
3701   assert (algo == PUBKEY_ALGO_RSA);
3702   
3703   /* Fixme: We don't have the serialnumber available, thus passing NULL. */
3704   rc = agent_scd_genkey (&info, keyno, 1, NULL, *timestamp);
3705 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3706 /*      { */
3707 /*        tty_printf ("\n"); */
3708 /*        log_error ("WARNING: key does already exists!\n"); */
3709 /*        tty_printf ("\n"); */
3710 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3711 /*                                    _("Replace existing key? "))) */
3712 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3713 /*      } */
3714
3715   if (rc)
3716     {
3717       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3718       return rc;
3719     }
3720   if ( !info.n || !info.e )
3721     {
3722       log_error ("communication error with SCD\n");
3723       gcry_mpi_release (info.n);
3724       gcry_mpi_release (info.e);
3725       return gpg_error (GPG_ERR_GENERAL);
3726     }
3727   
3728   if (*timestamp != info.created_at)
3729     log_info ("Note that the key does not use the suggested creation date\n");
3730   *timestamp = info.created_at;
3731
3732   pk = xcalloc (1, sizeof *pk );
3733   sk = xcalloc (1, sizeof *sk );
3734   sk->timestamp = pk->timestamp = info.created_at;
3735   sk->version = pk->version = 4;
3736   if (expireval)
3737       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3738   sk->pubkey_algo = pk->pubkey_algo = algo;
3739   pk->pkey[0] = info.n;
3740   pk->pkey[1] = info.e; 
3741   sk->skey[0] = gcry_mpi_copy (pk->pkey[0]);
3742   sk->skey[1] = gcry_mpi_copy (pk->pkey[1]);
3743   sk->skey[2] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
3744   sk->is_protected = 1;
3745   sk->protect.s2k.mode = 1002;
3746   s = get_parameter_value (para, pSERIALNO);
3747   if (s)
3748     {
3749       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3750            sk->protect.ivlen++, s += 2)
3751         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3752     }
3753
3754   if( ret_sk )
3755     *ret_sk = sk;
3756
3757   pkt = xcalloc (1,sizeof *pkt);
3758   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3759   pkt->pkt.public_key = pk;
3760   add_kbnode(pub_root, new_kbnode( pkt ));
3761
3762   pkt = xcalloc (1,sizeof *pkt);
3763   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3764   pkt->pkt.secret_key = sk;
3765   add_kbnode(sec_root, new_kbnode( pkt ));
3766
3767   return 0;
3768 #else
3769   return gpg_error (GPG_ERR_NOT_SUPPORTED);
3770 #endif /*!ENABLE_CARD_SUPPORT*/
3771 }
3772
3773
3774
3775 static int
3776 gen_card_key_with_backup (int algo, int keyno, int is_primary,
3777                           KBNODE pub_root, u32 timestamp,
3778                           u32 expireval, struct para_data_s *para,
3779                           const char *backup_dir)
3780 {
3781 #ifdef ENABLE_CARD_SUPPORT
3782   int rc;
3783   const char *s;
3784   PACKET *pkt;
3785   PKT_secret_key *sk, *sk_unprotected = NULL, *sk_protected = NULL;
3786   PKT_public_key *pk;
3787   size_t n;
3788   int i;
3789   unsigned int nbits;
3790     
3791   /* Get the size of the key directly from the card.  */
3792   {
3793     struct agent_card_info_s info;
3794     
3795     memset (&info, 0, sizeof info);
3796     if (!agent_scd_getattr ("KEY-ATTR", &info)
3797         && info.key_attr[1].algo)
3798       nbits = info.key_attr[1].nbits;
3799     else
3800       nbits = 1024; /* All pre-v2.0 cards.  */
3801     agent_release_card_info (&info);
3802   }
3803
3804   /* Create a key of this size in memory.  */
3805   rc = generate_raw_key (algo, nbits, timestamp,
3806                          &sk_unprotected, &sk_protected);
3807   if (rc)
3808     return rc;
3809
3810   /* Store the key to the card. */
3811   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
3812   if (rc)
3813     {
3814       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
3815       free_secret_key (sk_unprotected);
3816       free_secret_key (sk_protected);
3817       write_status_errcode ("save_key_to_card", rc);
3818       return rc;
3819     }
3820
3821   /* Get rid of the secret key parameters and store the serial numer. */
3822   sk = sk_unprotected;
3823   n = pubkey_get_nskey (sk->pubkey_algo);
3824   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
3825     {
3826       gcry_mpi_release (sk->skey[i]);
3827       sk->skey[i] = NULL;
3828     }
3829   i = pubkey_get_npkey (sk->pubkey_algo);
3830   sk->skey[i] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
3831   sk->is_protected = 1;
3832   sk->protect.s2k.mode = 1002;
3833   s = get_parameter_value (para, pSERIALNO);
3834   assert (s);
3835   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3836        sk->protect.ivlen++, s += 2)
3837     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3838
3839   /* Now write the *protected* secret key to the file.  */
3840   {
3841     char name_buffer[50];
3842     char *fname;
3843     IOBUF fp;
3844     mode_t oldmask;
3845
3846     keyid_from_sk (sk, NULL);
3847     snprintf (name_buffer, sizeof name_buffer, "sk_%08lX%08lX.gpg",
3848               (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
3849
3850     fname = make_filename (backup_dir, name_buffer, NULL);
3851     oldmask = umask (077);
3852     if (is_secured_filename (fname))
3853       {
3854         fp = NULL;
3855         gpg_err_set_errno (EPERM);
3856       }
3857     else
3858       fp = iobuf_create (fname);
3859     umask (oldmask);
3860     if (!fp) 
3861       {
3862         rc = gpg_error_from_syserror ();
3863         log_error (_("can't create backup file `%s': %s\n"),
3864                    fname, strerror(errno) );
3865         xfree (fname);
3866         free_secret_key (sk_unprotected);
3867         free_secret_key (sk_protected);
3868         return rc;
3869       }
3870
3871     pkt = xcalloc (1, sizeof *pkt);
3872     pkt->pkttype = PKT_SECRET_KEY;
3873     pkt->pkt.secret_key = sk_protected;
3874     sk_protected = NULL;
3875
3876     rc = build_packet (fp, pkt);
3877     if (rc)
3878       {
3879         log_error("build packet failed: %s\n", g10_errstr(rc) );
3880         iobuf_cancel (fp);
3881       }
3882     else
3883       {
3884         unsigned char array[MAX_FINGERPRINT_LEN];
3885         char *fprbuf, *p;
3886        
3887         iobuf_close (fp);
3888         iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
3889         log_info (_("NOTE: backup of card key saved to `%s'\n"), fname);
3890
3891         fingerprint_from_sk (sk, array, &n);
3892         p = fprbuf = xmalloc (MAX_FINGERPRINT_LEN*2 + 1 + 1);
3893         for (i=0; i < n ; i++, p += 2)
3894           sprintf (p, "%02X", array[i]);
3895         *p++ = ' ';
3896         *p = 0;
3897
3898         write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED,
3899                                       fprbuf,
3900                                       fname, strlen (fname),
3901                                       0);
3902         xfree (fprbuf);
3903       }
3904     free_packet (pkt);
3905     xfree (pkt);
3906     xfree (fname);
3907     if (rc)
3908       {
3909         free_secret_key (sk_unprotected);
3910         return rc;
3911       }
3912   }
3913
3914   /* Create the public key from the secret key. */
3915   pk = xcalloc (1, sizeof *pk );
3916   pk->timestamp = sk->timestamp;
3917   pk->version = sk->version;
3918   if (expireval)
3919       pk->expiredate = sk->expiredate = sk->timestamp + expireval;
3920   pk->pubkey_algo = sk->pubkey_algo;
3921   n = pubkey_get_npkey (sk->pubkey_algo);
3922   for (i=0; i < n; i++)
3923     pk->pkey[i] = mpi_copy (sk->skey[i]);
3924
3925   /* Build packets and add them to the node lists.  */
3926   pkt = xcalloc (1,sizeof *pkt);
3927   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3928   pkt->pkt.public_key = pk;
3929   add_kbnode(pub_root, new_kbnode( pkt ));
3930
3931   pkt = xcalloc (1,sizeof *pkt);
3932   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3933   pkt->pkt.secret_key = sk;
3934   add_kbnode(sec_root, new_kbnode( pkt ));
3935
3936   return 0;
3937 #else
3938   return gpg_error (GPG_ERR_NOT_SUPPORTED);
3939 #endif /*!ENABLE_CARD_SUPPORT*/
3940 }
3941
3942
3943 #ifdef ENABLE_CARD_SUPPORT
3944 int
3945 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
3946 {
3947   int rc;
3948   unsigned char *rsa_n = NULL;
3949   unsigned char *rsa_e = NULL;
3950   unsigned char *rsa_p = NULL;
3951   unsigned char *rsa_q = NULL;
3952   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
3953   unsigned char *sexp = NULL;
3954   unsigned char *p;
3955   char numbuf[55], numbuf2[50];
3956
3957   assert (is_RSA (sk->pubkey_algo));
3958   assert (!sk->is_protected);
3959
3960   /* Copy the parameters into straight buffers. */
3961   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_n, &rsa_n_len, sk->skey[0]);
3962   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_e, &rsa_e_len, sk->skey[1]);
3963   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_p, &rsa_p_len, sk->skey[3]);
3964   gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_q, &rsa_q_len, sk->skey[4]);
3965   if (!rsa_n || !rsa_e || !rsa_p || !rsa_q)
3966     {
3967       rc = G10ERR_INV_ARG;
3968       goto leave;
3969     }
3970
3971    /* Put the key into an S-expression. */
3972   sexp = p = xmalloc_secure (30
3973                              + rsa_n_len + rsa_e_len + rsa_p_len + rsa_q_len
3974                              + 4*sizeof (numbuf) + 25 + sizeof(numbuf) + 20);
3975
3976   p = stpcpy (p,"(11:private-key(3:rsa(1:n");
3977   sprintf (numbuf, "%u:", (unsigned int)rsa_n_len);
3978   p = stpcpy (p, numbuf);
3979   memcpy (p, rsa_n, rsa_n_len);
3980   p += rsa_n_len;
3981
3982   sprintf (numbuf, ")(1:e%u:", (unsigned int)rsa_e_len);
3983   p = stpcpy (p, numbuf);
3984   memcpy (p, rsa_e, rsa_e_len);
3985   p += rsa_e_len;
3986
3987   sprintf (numbuf, ")(1:p%u:", (unsigned int)rsa_p_len);
3988   p = stpcpy (p, numbuf);
3989   memcpy (p, rsa_p, rsa_p_len);
3990   p += rsa_p_len;
3991
3992   sprintf (numbuf, ")(1:q%u:", (unsigned int)rsa_q_len);
3993   p = stpcpy (p, numbuf);
3994   memcpy (p, rsa_q, rsa_q_len);
3995   p += rsa_q_len;
3996
3997   p = stpcpy (p,"))(10:created-at");
3998   sprintf (numbuf2, "%lu", (unsigned long)sk->timestamp);
3999   sprintf (numbuf, "%lu:", (unsigned long)strlen (numbuf2));
4000   p = stpcpy (stpcpy (stpcpy (p, numbuf), numbuf2), "))");
4001
4002   /* Fixme: Unfortunately we don't have the serialnumber available -
4003      thus we can't pass it down to the agent. */ 
4004   rc = agent_scd_writekey (keyno, NULL, sexp, p - sexp);
4005
4006  leave:
4007   xfree (sexp);
4008   xfree (rsa_n);
4009   xfree (rsa_e);
4010   xfree (rsa_p);
4011   xfree (rsa_q);
4012   return rc;
4013 }
4014 #endif /*ENABLE_CARD_SUPPORT*/