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