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