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