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