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