gpg: Allow predefined names as answer to the keygen.algo prompt.
[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 = NULL;
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       xfree (answer);
1736       answer = cpr_get ("keygen.algo", _("Your selection? "));
1737       cpr_kill_prompt ();
1738       algo = *answer? atoi (answer) : 1;
1739       if ((algo == 1 || !strcmp (answer, "rsa+rsa")) && !addmode)
1740         {
1741           algo = PUBKEY_ALGO_RSA;
1742           *r_subkey_algo = PUBKEY_ALGO_RSA;
1743           break;
1744         }
1745       else if ((algo == 2 || !strcmp (answer, "dsa+elg")) && !addmode)
1746         {
1747           algo = PUBKEY_ALGO_DSA;
1748           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
1749           break;
1750         }
1751       else if (algo == 3 || !strcmp (answer, "dsa"))
1752         {
1753           algo = PUBKEY_ALGO_DSA;
1754           *r_usage = PUBKEY_USAGE_SIG;
1755           break;
1756         }
1757       else if (algo == 4 || !strcmp (answer, "rsa/s"))
1758         {
1759           algo = PUBKEY_ALGO_RSA;
1760           *r_usage = PUBKEY_USAGE_SIG;
1761           break;
1762         }
1763       else if ((algo == 5 || !strcmp (answer, "elg")) && addmode)
1764         {
1765           algo = PUBKEY_ALGO_ELGAMAL_E;
1766           *r_usage = PUBKEY_USAGE_ENC;
1767           break;
1768         }
1769       else if ((algo == 6 || !strcmp (answer, "rsa/e")) && addmode)
1770         {
1771           algo = PUBKEY_ALGO_RSA;
1772           *r_usage = PUBKEY_USAGE_ENC;
1773           break;
1774         }
1775       else if ((algo == 7 || !strcmp (answer, "dsa/*")) && opt.expert)
1776         {
1777           algo = PUBKEY_ALGO_DSA;
1778           *r_usage = ask_key_flags (algo, addmode);
1779           break;
1780         }
1781       else if ((algo == 8 || !strcmp (answer, "rsa/*")) && 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
1792   xfree(answer);
1793   return algo;
1794 }
1795
1796
1797 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
1798    is not 0, the function asks for the size of the encryption
1799    subkey. */
1800 static unsigned
1801 ask_keysize (int algo, unsigned int primary_keysize)
1802 {
1803   unsigned int nbits, min, def = DEFAULT_STD_KEYSIZE, max=4096;
1804   int for_subkey = !!primary_keysize;
1805   int autocomp = 0;
1806
1807   if(opt.expert)
1808     min=512;
1809   else
1810     min=1024;
1811
1812   if (primary_keysize && !opt.expert)
1813     {
1814       /* Deduce the subkey size from the primary key size.  */
1815       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
1816         nbits = 3072; /* For performance reasons we don't support more
1817                          than 3072 bit DSA.  However we won't see this
1818                          case anyway because DSA can't be used as an
1819                          encryption subkey ;-). */
1820       else
1821         nbits = primary_keysize;
1822       autocomp = 1;
1823       goto leave;
1824     }
1825
1826   switch(algo)
1827     {
1828     case PUBKEY_ALGO_DSA:
1829       def=2048;
1830       max=3072;
1831       break;
1832
1833     case PUBKEY_ALGO_RSA:
1834       min=1024;
1835       break;
1836     }
1837
1838   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
1839              openpgp_pk_algo_name (algo), min, max);
1840
1841   for(;;)
1842     {
1843       char *prompt, *answer;
1844
1845       if (for_subkey)
1846         prompt = xasprintf (_("What keysize do you want "
1847                               "for the subkey? (%u) "), def);
1848       else
1849         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
1850       answer = cpr_get ("keygen.size", prompt);
1851       cpr_kill_prompt ();
1852       nbits = *answer? atoi (answer): def;
1853       xfree(prompt);
1854       xfree(answer);
1855
1856       if(nbits<min || nbits>max)
1857         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
1858                    openpgp_pk_algo_name (algo), min, max);
1859       else
1860         break;
1861     }
1862
1863   tty_printf(_("Requested keysize is %u bits\n"), nbits );
1864
1865  leave:
1866   if( algo == PUBKEY_ALGO_DSA && (nbits % 64) )
1867     {
1868       nbits = ((nbits + 63) / 64) * 64;
1869       if (!autocomp)
1870         tty_printf(_("rounded up to %u bits\n"), nbits );
1871     }
1872   else if( (nbits % 32) )
1873     {
1874       nbits = ((nbits + 31) / 32) * 32;
1875       if (!autocomp)
1876         tty_printf(_("rounded up to %u bits\n"), nbits );
1877     }
1878
1879   return nbits;
1880 }
1881
1882
1883 /****************
1884  * Parse an expire string and return its value in seconds.
1885  * Returns (u32)-1 on error.
1886  * This isn't perfect since scan_isodatestr returns unix time, and
1887  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
1888  * Because of this, we only permit setting expirations up to 2106, but
1889  * OpenPGP could theoretically allow up to 2242.  I think we'll all
1890  * just cope for the next few years until we get a 64-bit time_t or
1891  * similar.
1892  */
1893 u32
1894 parse_expire_string( const char *string )
1895 {
1896   int mult;
1897   u32 seconds;
1898   u32 abs_date = 0;
1899   u32 curtime = make_timestamp ();
1900   time_t tt;
1901
1902   if (!*string)
1903     seconds = 0;
1904   else if (!strncmp (string, "seconds=", 8))
1905     seconds = atoi (string+8);
1906   else if ((abs_date = scan_isodatestr(string))
1907            && (abs_date+86400/2) > curtime)
1908     seconds = (abs_date+86400/2) - curtime;
1909   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
1910     seconds = (u32)tt - curtime;
1911   else if ((mult = check_valid_days (string)))
1912     seconds = atoi (string) * 86400L * mult;
1913   else
1914     seconds = (u32)(-1);
1915
1916   return seconds;
1917 }
1918
1919 /* Parsean Creation-Date string which is either "1986-04-26" or
1920    "19860426T042640".  Returns 0 on error. */
1921 static u32
1922 parse_creation_string (const char *string)
1923 {
1924   u32 seconds;
1925
1926   if (!*string)
1927     seconds = 0;
1928   else if ( !strncmp (string, "seconds=", 8) )
1929     seconds = atoi (string+8);
1930   else if ( !(seconds = scan_isodatestr (string)))
1931     {
1932       time_t tmp = isotime2epoch (string);
1933       seconds = (tmp == (time_t)(-1))? 0 : tmp;
1934     }
1935   return seconds;
1936 }
1937
1938
1939 /* object == 0 for a key, and 1 for a sig */
1940 u32
1941 ask_expire_interval(int object,const char *def_expire)
1942 {
1943     u32 interval;
1944     char *answer;
1945
1946     switch(object)
1947       {
1948       case 0:
1949         if(def_expire)
1950           BUG();
1951         tty_printf(_("Please specify how long the key should be valid.\n"
1952                      "         0 = key does not expire\n"
1953                      "      <n>  = key expires in n days\n"
1954                      "      <n>w = key expires in n weeks\n"
1955                      "      <n>m = key expires in n months\n"
1956                      "      <n>y = key expires in n years\n"));
1957         break;
1958
1959       case 1:
1960         if(!def_expire)
1961           BUG();
1962         tty_printf(_("Please specify how long the signature should be valid.\n"
1963                      "         0 = signature does not expire\n"
1964                      "      <n>  = signature expires in n days\n"
1965                      "      <n>w = signature expires in n weeks\n"
1966                      "      <n>m = signature expires in n months\n"
1967                      "      <n>y = signature expires in n years\n"));
1968         break;
1969
1970       default:
1971         BUG();
1972       }
1973
1974     /* Note: The elgamal subkey for DSA has no expiration date because
1975      * it must be signed with the DSA key and this one has the expiration
1976      * date */
1977
1978     answer = NULL;
1979     for(;;)
1980       {
1981         u32 curtime;
1982
1983         xfree(answer);
1984         if(object==0)
1985           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1986         else
1987           {
1988             char *prompt;
1989
1990 #define PROMPTSTRING _("Signature is valid for? (%s) ")
1991             /* This will actually end up larger than necessary because
1992                of the 2 bytes for '%s' */
1993             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
1994             sprintf(prompt,PROMPTSTRING,def_expire);
1995 #undef PROMPTSTRING
1996
1997             answer = cpr_get("siggen.valid",prompt);
1998             xfree(prompt);
1999
2000             if(*answer=='\0')
2001               answer=xstrdup(def_expire);
2002           }
2003         cpr_kill_prompt();
2004         trim_spaces(answer);
2005         curtime = make_timestamp ();
2006         interval = parse_expire_string( answer );
2007         if( interval == (u32)-1 )
2008           {
2009             tty_printf(_("invalid value\n"));
2010             continue;
2011           }
2012
2013         if( !interval )
2014           {
2015             tty_printf((object==0)
2016                        ? _("Key does not expire at all\n")
2017                        : _("Signature does not expire at all\n"));
2018           }
2019         else
2020           {
2021             tty_printf(object==0
2022                        ? _("Key expires at %s\n")
2023                        : _("Signature expires at %s\n"),
2024                        asctimestamp((ulong)(curtime + interval) ) );
2025 #if SIZEOF_TIME_T <= 4
2026             if ( (time_t)((ulong)(curtime+interval)) < 0 )
2027               tty_printf (_("Your system can't display dates beyond 2038.\n"
2028                             "However, it will be correctly handled up to"
2029                             " 2106.\n"));
2030             else
2031 #endif /*SIZEOF_TIME_T*/
2032               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
2033                 {
2034                   tty_printf (_("invalid value\n"));
2035                   continue;
2036                 }
2037           }
2038
2039         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
2040                                                    _("Is this correct? (y/N) ")) )
2041           break;
2042       }
2043
2044     xfree(answer);
2045     return interval;
2046 }
2047
2048 u32
2049 ask_expiredate()
2050 {
2051     u32 x = ask_expire_interval(0,NULL);
2052     return x? make_timestamp() + x : 0;
2053 }
2054
2055
2056
2057 static PKT_user_id *
2058 uid_from_string (const char *string)
2059 {
2060   size_t n;
2061   PKT_user_id *uid;
2062
2063   n = strlen (string);
2064   uid = xmalloc_clear (sizeof *uid + n);
2065   uid->len = n;
2066   strcpy (uid->name, string);
2067   uid->ref = 1;
2068   return uid;
2069 }
2070
2071
2072 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
2073    printed for use during a new key creation.  If KEYBLOCK is not NULL
2074    the function prevents the creation of an already existing user
2075    ID.  */
2076 static char *
2077 ask_user_id (int mode, KBNODE keyblock)
2078 {
2079     char *answer;
2080     char *aname, *acomment, *amail, *uid;
2081
2082     if ( !mode )
2083       {
2084         /* TRANSLATORS: This is the new string telling the user what
2085            gpg is now going to do (i.e. ask for the parts of the user
2086            ID).  Note that if you do not tyranslated this string, a
2087            different string will be used used, which might still have
2088            a correct transaltion.  */
2089         const char *s1 =
2090           N_("\n"
2091              "GnuPG needs to construct a user ID to identify your key.\n"
2092              "\n");
2093         const char *s2 = _(s1);
2094
2095         if (!strcmp (s1, s2))
2096           {
2097             /* There is no translation for the string thus we to use
2098                the old info text.  gettext has no way to tell whether
2099                a translation is actually available, thus we need to
2100                to compare again. */
2101             /* TRANSLATORS: This string is in general not anymore used
2102                but you should keep your existing translation.  In case
2103                the new string is not translated this old string will
2104                be used. */
2105             const char *s3 = N_("\n"
2106 "You need a user ID to identify your key; "
2107                                         "the software constructs the user ID\n"
2108 "from the Real Name, Comment and Email Address in this form:\n"
2109 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
2110             const char *s4 = _(s3);
2111             if (strcmp (s3, s4))
2112               s2 = s3; /* A translation exists - use it. */
2113           }
2114         tty_printf ("%s", s2) ;
2115       }
2116     uid = aname = acomment = amail = NULL;
2117     for(;;) {
2118         char *p;
2119         int fail=0;
2120
2121         if( !aname ) {
2122             for(;;) {
2123                 xfree(aname);
2124                 aname = cpr_get("keygen.name",_("Real name: "));
2125                 trim_spaces(aname);
2126                 cpr_kill_prompt();
2127
2128                 if( opt.allow_freeform_uid )
2129                     break;
2130
2131                 if( strpbrk( aname, "<>" ) )
2132                     tty_printf(_("Invalid character in name\n"));
2133                 else if( digitp(aname) )
2134                     tty_printf(_("Name may not start with a digit\n"));
2135                 else if( strlen(aname) < 5 )
2136                     tty_printf(_("Name must be at least 5 characters long\n"));
2137                 else
2138                     break;
2139             }
2140         }
2141         if( !amail ) {
2142             for(;;) {
2143                 xfree(amail);
2144                 amail = cpr_get("keygen.email",_("Email address: "));
2145                 trim_spaces(amail);
2146                 cpr_kill_prompt();
2147                 if( !*amail || opt.allow_freeform_uid )
2148                     break;   /* no email address is okay */
2149                 else if ( !is_valid_mailbox (amail) )
2150                     tty_printf(_("Not a valid email address\n"));
2151                 else
2152                     break;
2153             }
2154         }
2155         if( !acomment ) {
2156             for(;;) {
2157                 xfree(acomment);
2158                 acomment = cpr_get("keygen.comment",_("Comment: "));
2159                 trim_spaces(acomment);
2160                 cpr_kill_prompt();
2161                 if( !*acomment )
2162                     break;   /* no comment is okay */
2163                 else if( strpbrk( acomment, "()" ) )
2164                     tty_printf(_("Invalid character in comment\n"));
2165                 else
2166                     break;
2167             }
2168         }
2169
2170
2171         xfree(uid);
2172         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
2173         p = stpcpy(p, aname );
2174         if( *acomment )
2175             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
2176         if( *amail )
2177             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
2178
2179         /* Append a warning if the RNG is switched into fake mode.  */
2180         if ( random_is_faked ()  )
2181           strcpy(p, " (insecure!)" );
2182
2183         /* print a note in case that UTF8 mapping has to be done */
2184         for(p=uid; *p; p++ ) {
2185             if( *p & 0x80 ) {
2186                 tty_printf(_("You are using the `%s' character set.\n"),
2187                            get_native_charset() );
2188                 break;
2189             }
2190         }
2191
2192         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2193
2194         if( !*amail && !opt.allow_freeform_uid
2195             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2196             fail = 1;
2197             tty_printf(_("Please don't put the email address "
2198                          "into the real name or the comment\n") );
2199         }
2200
2201         if (!fail && keyblock)
2202           {
2203             PKT_user_id *uidpkt = uid_from_string (uid);
2204             KBNODE node;
2205
2206             for (node=keyblock; node && !fail; node=node->next)
2207               if (!is_deleted_kbnode (node)
2208                   && node->pkt->pkttype == PKT_USER_ID
2209                   && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2210                 fail = 1;
2211             if (fail)
2212               tty_printf (_("Such a user ID already exists on this key!\n"));
2213             free_user_id (uidpkt);
2214           }
2215
2216         for(;;) {
2217             /* TRANSLATORS: These are the allowed answers in
2218                lower and uppercase.  Below you will find the matching
2219                string which should be translated accordingly and the
2220                letter changed to match the one in the answer string.
2221
2222                  n = Change name
2223                  c = Change comment
2224                  e = Change email
2225                  o = Okay (ready, continue)
2226                  q = Quit
2227              */
2228             const char *ansstr = _("NnCcEeOoQq");
2229
2230             if( strlen(ansstr) != 10 )
2231                 BUG();
2232             if( cpr_enabled() ) {
2233                 answer = xstrdup (ansstr + (fail?8:6));
2234                 answer[1] = 0;
2235             }
2236             else {
2237                 answer = cpr_get("keygen.userid.cmd", fail?
2238                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2239                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2240                 cpr_kill_prompt();
2241             }
2242             if( strlen(answer) > 1 )
2243                 ;
2244             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2245                 xfree(aname); aname = NULL;
2246                 break;
2247             }
2248             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2249                 xfree(acomment); acomment = NULL;
2250                 break;
2251             }
2252             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2253                 xfree(amail); amail = NULL;
2254                 break;
2255             }
2256             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2257                 if( fail ) {
2258                     tty_printf(_("Please correct the error first\n"));
2259                 }
2260                 else {
2261                     xfree(aname); aname = NULL;
2262                     xfree(acomment); acomment = NULL;
2263                     xfree(amail); amail = NULL;
2264                     break;
2265                 }
2266             }
2267             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2268                 xfree(aname); aname = NULL;
2269                 xfree(acomment); acomment = NULL;
2270                 xfree(amail); amail = NULL;
2271                 xfree(uid); uid = NULL;
2272                 break;
2273             }
2274             xfree(answer);
2275         }
2276         xfree(answer);
2277         if( !aname && !acomment && !amail )
2278             break;
2279         xfree(uid); uid = NULL;
2280     }
2281     if( uid ) {
2282         char *p = native_to_utf8( uid );
2283         xfree( uid );
2284         uid = p;
2285     }
2286     return uid;
2287 }
2288
2289
2290 /*  MODE  0 - standard
2291           1 - Ask for passphrase of the card backup key.  */
2292 static DEK *
2293 do_ask_passphrase (STRING2KEY **ret_s2k, int mode, int *r_canceled)
2294 {
2295     DEK *dek = NULL;
2296     STRING2KEY *s2k;
2297     const char *errtext = NULL;
2298     const char *custdesc = NULL;
2299
2300     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
2301
2302     if (mode == 1)
2303       custdesc = _("Please enter a passphrase to protect the off-card "
2304                    "backup of the new encryption key.");
2305
2306     s2k = xmalloc_secure( sizeof *s2k );
2307     for(;;) {
2308         s2k->mode = opt.s2k_mode;
2309         s2k->hash_algo = S2K_DIGEST_ALGO;
2310         dek = passphrase_to_dek_ext (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2311                                      errtext, custdesc, NULL, r_canceled);
2312         if (!dek && *r_canceled) {
2313             xfree(dek); dek = NULL;
2314             xfree(s2k); s2k = NULL;
2315             break;
2316         }
2317         else if( !dek ) {
2318             errtext = N_("passphrase not correctly repeated; try again");
2319             tty_printf(_("%s.\n"), _(errtext));
2320         }
2321         else if( !dek->keylen ) {
2322             xfree(dek); dek = NULL;
2323             xfree(s2k); s2k = NULL;
2324             tty_printf(_(
2325             "You don't want a passphrase - this is probably a *bad* idea!\n"
2326             "I will do it anyway.  You can change your passphrase at any time,\n"
2327             "using this program with the option \"--edit-key\".\n\n"));
2328             break;
2329         }
2330         else
2331             break; /* okay */
2332     }
2333     *ret_s2k = s2k;
2334     return dek;
2335 }
2336
2337
2338 /* Basic key generation.  Here we divert to the actual generation
2339    routines based on the requested algorithm.  */
2340 static int
2341 do_create (int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
2342            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk,
2343            u32 timestamp, u32 expiredate, int is_subkey )
2344 {
2345   int rc=0;
2346
2347   if( !opt.batch )
2348     tty_printf(_(
2349 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2350 "some other action (type on the keyboard, move the mouse, utilize the\n"
2351 "disks) during the prime generation; this gives the random number\n"
2352 "generator a better chance to gain enough entropy.\n") );
2353
2354   if( algo == PUBKEY_ALGO_ELGAMAL_E )
2355     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk,
2356                  timestamp, expiredate, is_subkey);
2357   else if( algo == PUBKEY_ALGO_DSA )
2358     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk,
2359                  timestamp, expiredate, is_subkey);
2360   else if( algo == PUBKEY_ALGO_RSA )
2361     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk,
2362                  timestamp, expiredate, is_subkey);
2363   else
2364     BUG();
2365
2366   return rc;
2367 }
2368
2369
2370 /* Generate a new user id packet or return NULL if canceled.  If
2371    KEYBLOCK is not NULL the function prevents the creation of an
2372    already existing user ID.  */
2373 PKT_user_id *
2374 generate_user_id (KBNODE keyblock)
2375 {
2376   char *p;
2377
2378   p = ask_user_id (1, keyblock);
2379   if (!p)
2380     return NULL;  /* Canceled. */
2381   return uid_from_string (p);
2382 }
2383
2384
2385 static void
2386 release_parameter_list( struct para_data_s *r )
2387 {
2388     struct para_data_s *r2;
2389
2390     for( ; r ; r = r2 ) {
2391         r2 = r->next;
2392         if( r->key == pPASSPHRASE_DEK )
2393             xfree( r->u.dek );
2394         else if( r->key == pPASSPHRASE_S2K )
2395             xfree( r->u.s2k );
2396
2397         xfree(r);
2398     }
2399 }
2400
2401 static struct para_data_s *
2402 get_parameter( struct para_data_s *para, enum para_name key )
2403 {
2404     struct para_data_s *r;
2405
2406     for( r = para; r && r->key != key; r = r->next )
2407         ;
2408     return r;
2409 }
2410
2411 static const char *
2412 get_parameter_value( struct para_data_s *para, enum para_name key )
2413 {
2414     struct para_data_s *r = get_parameter( para, key );
2415     return (r && *r->u.value)? r->u.value : NULL;
2416 }
2417
2418 static int
2419 get_parameter_algo( struct para_data_s *para, enum para_name key,
2420                     int *r_default)
2421 {
2422   int i;
2423   struct para_data_s *r = get_parameter( para, key );
2424
2425   if (r_default)
2426     *r_default = 0;
2427
2428   if (!r)
2429     return -1;
2430
2431   if (!ascii_strcasecmp (r->u.value, "default"))
2432     {
2433       /* Note: If you change this default algo, remember to change it
2434          also in gpg.c:gpgconf_list.  */
2435       i = DEFAULT_STD_ALGO;
2436       if (r_default)
2437         *r_default = 1;
2438     }
2439   else if (digitp (r->u.value))
2440     i = atoi( r->u.value );
2441   else if (!strcmp (r->u.value, "ELG-E")
2442            || !strcmp (r->u.value, "ELG"))
2443     i = GCRY_PK_ELG_E;
2444   else
2445     i = gcry_pk_map_name (r->u.value);
2446
2447   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2448     i = 0; /* we don't want to allow generation of these algorithms */
2449   return i;
2450 }
2451
2452 /*
2453  * Parse the usage parameter and set the keyflags.  Returns -1 on
2454  * error, 0 for no usage given or 1 for usage available.
2455  */
2456 static int
2457 parse_parameter_usage (const char *fname,
2458                        struct para_data_s *para, enum para_name key)
2459 {
2460     struct para_data_s *r = get_parameter( para, key );
2461     char *p, *pn;
2462     unsigned int use;
2463
2464     if( !r )
2465         return 0; /* none (this is an optional parameter)*/
2466
2467     use = 0;
2468     pn = r->u.value;
2469     while ( (p = strsep (&pn, " \t,")) ) {
2470         if ( !*p)
2471             ;
2472         else if ( !ascii_strcasecmp (p, "sign") )
2473             use |= PUBKEY_USAGE_SIG;
2474         else if ( !ascii_strcasecmp (p, "encrypt") )
2475             use |= PUBKEY_USAGE_ENC;
2476         else if ( !ascii_strcasecmp (p, "auth") )
2477             use |= PUBKEY_USAGE_AUTH;
2478         else {
2479             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2480             return -1; /* error */
2481         }
2482     }
2483     r->u.usage = use;
2484     return 1;
2485 }
2486
2487 static int
2488 parse_revocation_key (const char *fname,
2489                       struct para_data_s *para, enum para_name key)
2490 {
2491   struct para_data_s *r = get_parameter( para, key );
2492   struct revocation_key revkey;
2493   char *pn;
2494   int i;
2495
2496   if( !r )
2497     return 0; /* none (this is an optional parameter) */
2498
2499   pn = r->u.value;
2500
2501   revkey.class=0x80;
2502   revkey.algid=atoi(pn);
2503   if(!revkey.algid)
2504     goto fail;
2505
2506   /* Skip to the fpr */
2507   while(*pn && *pn!=':')
2508     pn++;
2509
2510   if(*pn!=':')
2511     goto fail;
2512
2513   pn++;
2514
2515   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2516     {
2517       int c=hextobyte(pn);
2518       if(c==-1)
2519         goto fail;
2520
2521       revkey.fpr[i]=c;
2522     }
2523
2524   /* skip to the tag */
2525   while(*pn && *pn!='s' && *pn!='S')
2526     pn++;
2527
2528   if(ascii_strcasecmp(pn,"sensitive")==0)
2529     revkey.class|=0x40;
2530
2531   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2532
2533   return 0;
2534
2535   fail:
2536   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2537   return -1; /* error */
2538 }
2539
2540
2541 static u32
2542 get_parameter_u32( struct para_data_s *para, enum para_name key )
2543 {
2544   struct para_data_s *r = get_parameter( para, key );
2545
2546   if( !r )
2547     return 0;
2548   if( r->key == pKEYCREATIONDATE )
2549     return r->u.creation;
2550   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2551     return r->u.expire;
2552   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2553     return r->u.usage;
2554
2555   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2556 }
2557
2558 static unsigned int
2559 get_parameter_uint( struct para_data_s *para, enum para_name key )
2560 {
2561     return get_parameter_u32( para, key );
2562 }
2563
2564 static DEK *
2565 get_parameter_dek( struct para_data_s *para, enum para_name key )
2566 {
2567     struct para_data_s *r = get_parameter( para, key );
2568     return r? r->u.dek : NULL;
2569 }
2570
2571 static STRING2KEY *
2572 get_parameter_s2k( struct para_data_s *para, enum para_name key )
2573 {
2574     struct para_data_s *r = get_parameter( para, key );
2575     return r? r->u.s2k : NULL;
2576 }
2577
2578 static struct revocation_key *
2579 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2580 {
2581     struct para_data_s *r = get_parameter( para, key );
2582     return r? &r->u.revkey : NULL;
2583 }
2584
2585 static int
2586 proc_parameter_file( struct para_data_s *para, const char *fname,
2587                      struct output_control_s *outctrl, int card )
2588 {
2589   struct para_data_s *r;
2590   const char *s1, *s2, *s3;
2591   size_t n;
2592   char *p;
2593   int is_default = 0;
2594   int have_user_id = 0;
2595   int err, algo;
2596
2597   /* Check that we have all required parameters. */
2598   r = get_parameter( para, pKEYTYPE );
2599   if(r)
2600     {
2601       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
2602       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2603         {
2604           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2605           return -1;
2606         }
2607     }
2608   else
2609     {
2610       log_error ("%s: no Key-Type specified\n",fname);
2611       return -1;
2612     }
2613
2614   err = parse_parameter_usage (fname, para, pKEYUSAGE);
2615   if (!err)
2616     {
2617       /* Default to algo capabilities if key-usage is not provided and
2618          no default algorithm has been requested.  */
2619       r = xmalloc_clear(sizeof(*r));
2620       r->key = pKEYUSAGE;
2621       r->u.usage = (is_default
2622                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
2623                     : openpgp_pk_algo_usage(algo));
2624       r->next = para;
2625       para = r;
2626     }
2627   else if (err == -1)
2628     return -1;
2629   else
2630     {
2631       r = get_parameter (para, pKEYUSAGE);
2632       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2633         {
2634           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
2635                      fname, r->lnr, algo);
2636           return -1;
2637         }
2638     }
2639
2640   is_default = 0;
2641   r = get_parameter( para, pSUBKEYTYPE );
2642   if(r)
2643     {
2644       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
2645       if (openpgp_pk_test_algo (algo))
2646         {
2647           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2648           return -1;
2649         }
2650
2651       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2652       if (!err)
2653         {
2654           /* Default to algo capabilities if subkey-usage is not
2655              provided */
2656           r = xmalloc_clear (sizeof(*r));
2657           r->key = pSUBKEYUSAGE;
2658           r->u.usage = (is_default
2659                         ? PUBKEY_USAGE_ENC
2660                         : openpgp_pk_algo_usage (algo));
2661           r->next = para;
2662           para = r;
2663         }
2664       else if (err == -1)
2665         return -1;
2666       else
2667         {
2668           r = get_parameter (para, pSUBKEYUSAGE);
2669           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2670             {
2671               log_error ("%s:%d: specified Subkey-Usage not allowed"
2672                          " for algo %d\n", fname, r->lnr, algo);
2673               return -1;
2674             }
2675         }
2676     }
2677
2678
2679   if( get_parameter_value( para, pUSERID ) )
2680     have_user_id=1;
2681   else
2682     {
2683       /* create the formatted user ID */
2684       s1 = get_parameter_value( para, pNAMEREAL );
2685       s2 = get_parameter_value( para, pNAMECOMMENT );
2686       s3 = get_parameter_value( para, pNAMEEMAIL );
2687       if( s1 || s2 || s3 )
2688         {
2689           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2690           r = xmalloc_clear( sizeof *r + n + 20 );
2691           r->key = pUSERID;
2692           p = r->u.value;
2693           if( s1 )
2694             p = stpcpy(p, s1 );
2695           if( s2 )
2696             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2697           if( s3 )
2698             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2699           r->next = para;
2700           para = r;
2701           have_user_id=1;
2702         }
2703     }
2704
2705   if(!have_user_id)
2706     {
2707       log_error("%s: no User-ID specified\n",fname);
2708       return -1;
2709     }
2710
2711   /* Set preferences, if any. */
2712   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2713
2714   /* Set keyserver, if any. */
2715   s1=get_parameter_value( para, pKEYSERVER );
2716   if(s1)
2717     {
2718       struct keyserver_spec *spec;
2719
2720       spec=parse_keyserver_uri(s1,1,NULL,0);
2721       if(spec)
2722         {
2723           free_keyserver_spec(spec);
2724           opt.def_keyserver_url=s1;
2725         }
2726       else
2727         {
2728           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
2729           return -1;
2730         }
2731     }
2732
2733   /* Set revoker, if any. */
2734   if (parse_revocation_key (fname, para, pREVOKER))
2735     return -1;
2736
2737   /* Make DEK and S2K from the Passphrase. */
2738   if (outctrl->ask_passphrase)
2739     {
2740       /* %ask-passphrase is active - ignore pPASSPRASE and ask.  This
2741          feature is required so that GUIs are able to do a key
2742          creation but have gpg-agent ask for the passphrase.  */
2743       int canceled = 0;
2744       STRING2KEY *s2k;
2745       DEK *dek;
2746
2747       dek = do_ask_passphrase (&s2k, 0, &canceled);
2748       if (dek)
2749         {
2750           r = xmalloc_clear( sizeof *r );
2751           r->key = pPASSPHRASE_DEK;
2752           r->u.dek = dek;
2753           r->next = para;
2754           para = r;
2755           r = xmalloc_clear( sizeof *r );
2756           r->key = pPASSPHRASE_S2K;
2757           r->u.s2k = s2k;
2758           r->next = para;
2759           para = r;
2760         }
2761
2762       if (canceled)
2763         {
2764           log_error ("%s:%d: key generation canceled\n", fname, r->lnr );
2765           return -1;
2766         }
2767     }
2768   else
2769     {
2770       r = get_parameter( para, pPASSPHRASE );
2771       if ( r && *r->u.value )
2772         {
2773           /* We have a plain text passphrase - create a DEK from it.
2774            * It is a little bit ridiculous to keep it in secure memory
2775            * but because we do this always, why not here.  */
2776           STRING2KEY *s2k;
2777           DEK *dek;
2778
2779           s2k = xmalloc_secure ( sizeof *s2k );
2780           s2k->mode = opt.s2k_mode;
2781           s2k->hash_algo = S2K_DIGEST_ALGO;
2782           set_next_passphrase ( r->u.value );
2783           dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2784                                    NULL, NULL);
2785           set_next_passphrase (NULL );
2786           assert (dek);
2787           memset (r->u.value, 0, strlen(r->u.value));
2788
2789           r = xmalloc_clear (sizeof *r);
2790           r->key = pPASSPHRASE_S2K;
2791           r->u.s2k = s2k;
2792           r->next = para;
2793           para = r;
2794           r = xmalloc_clear (sizeof *r);
2795           r->key = pPASSPHRASE_DEK;
2796           r->u.dek = dek;
2797           r->next = para;
2798           para = r;
2799         }
2800     }
2801
2802   /* Make KEYCREATIONDATE from Creation-Date.  */
2803   r = get_parameter (para, pCREATIONDATE);
2804   if (r && *r->u.value)
2805     {
2806       u32 seconds;
2807
2808       seconds = parse_creation_string (r->u.value);
2809       if (!seconds)
2810         {
2811           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
2812           return -1;
2813         }
2814       r->u.creation = seconds;
2815       r->key = pKEYCREATIONDATE;  /* Change that entry. */
2816     }
2817
2818   /* Make KEYEXPIRE from Expire-Date.  */
2819   r = get_parameter( para, pEXPIREDATE );
2820   if( r && *r->u.value )
2821     {
2822       u32 seconds;
2823
2824       seconds = parse_expire_string( r->u.value );
2825       if( seconds == (u32)-1 )
2826         {
2827           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2828           return -1;
2829         }
2830       r->u.expire = seconds;
2831       r->key = pKEYEXPIRE;  /* change hat entry */
2832       /* also set it for the subkey */
2833       r = xmalloc_clear( sizeof *r + 20 );
2834       r->key = pSUBKEYEXPIRE;
2835       r->u.expire = seconds;
2836       r->next = para;
2837       para = r;
2838     }
2839
2840   if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2841     log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2842     return -1;
2843   }
2844
2845   do_generate_keypair( para, outctrl, card );
2846   return 0;
2847 }
2848
2849
2850 /****************
2851  * Kludge to allow non interactive key generation controlled
2852  * by a parameter file.
2853  * Note, that string parameters are expected to be in UTF-8
2854  */
2855 static void
2856 read_parameter_file( const char *fname )
2857 {
2858     static struct { const char *name;
2859                     enum para_name key;
2860     } keywords[] = {
2861         { "Key-Type",       pKEYTYPE},
2862         { "Key-Length",     pKEYLENGTH },
2863         { "Key-Usage",      pKEYUSAGE },
2864         { "Subkey-Type",    pSUBKEYTYPE },
2865         { "Subkey-Length",  pSUBKEYLENGTH },
2866         { "Subkey-Usage",   pSUBKEYUSAGE },
2867         { "Name-Real",      pNAMEREAL },
2868         { "Name-Email",     pNAMEEMAIL },
2869         { "Name-Comment",   pNAMECOMMENT },
2870         { "Expire-Date",    pEXPIREDATE },
2871         { "Creation-Date",  pCREATIONDATE },
2872         { "Passphrase",     pPASSPHRASE },
2873         { "Preferences",    pPREFERENCES },
2874         { "Revoker",        pREVOKER },
2875         { "Handle",         pHANDLE },
2876         { "Keyserver",      pKEYSERVER },
2877         { NULL, 0 }
2878     };
2879     IOBUF fp;
2880     byte *line;
2881     unsigned int maxlen, nline;
2882     char *p;
2883     int lnr;
2884     const char *err = NULL;
2885     struct para_data_s *para, *r;
2886     int i;
2887     struct output_control_s outctrl;
2888
2889     memset( &outctrl, 0, sizeof( outctrl ) );
2890     outctrl.pub.afx = new_armor_context ();
2891     outctrl.sec.afx = new_armor_context ();
2892
2893     if( !fname || !*fname)
2894       fname = "-";
2895
2896     fp = iobuf_open (fname);
2897     if (fp && is_secured_file (iobuf_get_fd (fp)))
2898       {
2899         iobuf_close (fp);
2900         fp = NULL;
2901         errno = EPERM;
2902       }
2903     if (!fp) {
2904       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2905       return;
2906     }
2907     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2908
2909     lnr = 0;
2910     err = NULL;
2911     para = NULL;
2912     maxlen = 1024;
2913     line = NULL;
2914     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2915         char *keyword, *value;
2916
2917         lnr++;
2918         if( !maxlen ) {
2919             err = "line too long";
2920             break;
2921         }
2922         for( p = line; isspace(*(byte*)p); p++ )
2923             ;
2924         if( !*p || *p == '#' )
2925             continue;
2926         keyword = p;
2927         if( *keyword == '%' ) {
2928             for( ; !isspace(*(byte*)p); p++ )
2929                 ;
2930             if( *p )
2931                 *p++ = 0;
2932             for( ; isspace(*(byte*)p); p++ )
2933                 ;
2934             value = p;
2935             trim_trailing_ws( value, strlen(value) );
2936             if( !ascii_strcasecmp( keyword, "%echo" ) )
2937                 log_info("%s\n", value );
2938             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2939                 outctrl.dryrun = 1;
2940             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
2941                 outctrl.ask_passphrase = 1;
2942             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
2943                 outctrl.ask_passphrase = 0;
2944             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2945                 outctrl.lnr = lnr;
2946                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2947                   print_status_key_not_created
2948                     (get_parameter_value (para, pHANDLE));
2949                 release_parameter_list( para );
2950                 para = NULL;
2951             }
2952             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2953                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2954                     ; /* still the same file - ignore it */
2955                 else {
2956                     xfree( outctrl.pub.newfname );
2957                     outctrl.pub.newfname = xstrdup( value );
2958                     outctrl.use_files = 1;
2959                 }
2960             }
2961             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2962                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2963                     ; /* still the same file - ignore it */
2964                 else {
2965                    xfree( outctrl.sec.newfname );
2966                    outctrl.sec.newfname = xstrdup( value );
2967                    outctrl.use_files = 1;
2968                 }
2969             }
2970             else
2971                 log_info("skipping control `%s' (%s)\n", keyword, value );
2972
2973
2974             continue;
2975         }
2976
2977
2978         if( !(p = strchr( p, ':' )) || p == keyword ) {
2979             err = "missing colon";
2980             break;
2981         }
2982         if( *p )
2983             *p++ = 0;
2984         for( ; isspace(*(byte*)p); p++ )
2985             ;
2986         if( !*p ) {
2987             err = "missing argument";
2988             break;
2989         }
2990         value = p;
2991         trim_trailing_ws( value, strlen(value) );
2992
2993         for(i=0; keywords[i].name; i++ ) {
2994             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2995                 break;
2996         }
2997         if( !keywords[i].name ) {
2998             err = "unknown keyword";
2999             break;
3000         }
3001         if( keywords[i].key != pKEYTYPE && !para ) {
3002             err = "parameter block does not start with \"Key-Type\"";
3003             break;
3004         }
3005
3006         if( keywords[i].key == pKEYTYPE && para ) {
3007             outctrl.lnr = lnr;
3008             if (proc_parameter_file( para, fname, &outctrl, 0 ))
3009               print_status_key_not_created
3010                 (get_parameter_value (para, pHANDLE));
3011             release_parameter_list( para );
3012             para = NULL;
3013         }
3014         else {
3015             for( r = para; r; r = r->next ) {
3016                 if( r->key == keywords[i].key )
3017                     break;
3018             }
3019             if( r ) {
3020                 err = "duplicate keyword";
3021                 break;
3022             }
3023         }
3024         r = xmalloc_clear( sizeof *r + strlen( value ) );
3025         r->lnr = lnr;
3026         r->key = keywords[i].key;
3027         strcpy( r->u.value, value );
3028         r->next = para;
3029         para = r;
3030     }
3031     if( err )
3032         log_error("%s:%d: %s\n", fname, lnr, err );
3033     else if( iobuf_error (fp) ) {
3034         log_error("%s:%d: read error\n", fname, lnr);
3035     }
3036     else if( para ) {
3037         outctrl.lnr = lnr;
3038         if (proc_parameter_file( para, fname, &outctrl, 0 ))
3039           print_status_key_not_created (get_parameter_value (para, pHANDLE));
3040     }
3041
3042     if( outctrl.use_files ) { /* close open streams */
3043         iobuf_close( outctrl.pub.stream );
3044         iobuf_close( outctrl.sec.stream );
3045
3046         /* Must invalidate that ugly cache to actually close it.  */
3047         if (outctrl.pub.fname)
3048           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
3049         if (outctrl.sec.fname)
3050           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
3051
3052         xfree( outctrl.pub.fname );
3053         xfree( outctrl.pub.newfname );
3054         xfree( outctrl.sec.fname );
3055         xfree( outctrl.sec.newfname );
3056     }
3057
3058     release_parameter_list( para );
3059     iobuf_close (fp);
3060     release_armor_context (outctrl.pub.afx);
3061     release_armor_context (outctrl.sec.afx);
3062 }
3063
3064
3065 /*
3066  * Generate a keypair (fname is only used in batch mode) If
3067  * CARD_SERIALNO is not NULL the function will create the keys on an
3068  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
3069  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
3070  * generate in software, imported to the card and a backup file
3071  * written to directory given by this argument .
3072  */
3073 void
3074 generate_keypair (const char *fname, const char *card_serialno,
3075                   const char *backup_encryption_dir)
3076 {
3077   unsigned int nbits;
3078   char *uid = NULL;
3079   DEK *dek;
3080   STRING2KEY *s2k;
3081   int algo;
3082   unsigned int use;
3083   int both = 0;
3084   u32 expire;
3085   struct para_data_s *para = NULL;
3086   struct para_data_s *r;
3087   struct output_control_s outctrl;
3088   int canceled;
3089
3090   memset( &outctrl, 0, sizeof( outctrl ) );
3091
3092   if (opt.batch && card_serialno)
3093     {
3094       /* We don't yet support unattended key generation. */
3095       log_error (_("can't do this in batch mode\n"));
3096       return;
3097     }
3098
3099   if (opt.batch)
3100     {
3101       read_parameter_file( fname );
3102       return;
3103     }
3104
3105   if (card_serialno)
3106     {
3107 #ifdef ENABLE_CARD_SUPPORT
3108       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
3109       r->key = pSERIALNO;
3110       strcpy( r->u.value, card_serialno);
3111       r->next = para;
3112       para = r;
3113
3114       algo = PUBKEY_ALGO_RSA;
3115
3116       r = xcalloc (1, sizeof *r + 20 );
3117       r->key = pKEYTYPE;
3118       sprintf( r->u.value, "%d", algo );
3119       r->next = para;
3120       para = r;
3121       r = xcalloc (1, sizeof *r + 20 );
3122       r->key = pKEYUSAGE;
3123       strcpy (r->u.value, "sign");
3124       r->next = para;
3125       para = r;
3126
3127       r = xcalloc (1, sizeof *r + 20 );
3128       r->key = pSUBKEYTYPE;
3129       sprintf( r->u.value, "%d", algo );
3130       r->next = para;
3131       para = r;
3132       r = xcalloc (1, sizeof *r + 20 );
3133       r->key = pSUBKEYUSAGE;
3134       strcpy (r->u.value, "encrypt");
3135       r->next = para;
3136       para = r;
3137
3138       r = xcalloc (1, sizeof *r + 20 );
3139       r->key = pAUTHKEYTYPE;
3140       sprintf( r->u.value, "%d", algo );
3141       r->next = para;
3142       para = r;
3143
3144       if (backup_encryption_dir)
3145         {
3146           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
3147           r->key = pBACKUPENCDIR;
3148           strcpy (r->u.value, backup_encryption_dir);
3149           r->next = para;
3150           para = r;
3151         }
3152 #endif /*ENABLE_CARD_SUPPORT*/
3153     }
3154   else
3155     {
3156       int subkey_algo;
3157
3158       algo = ask_algo (0, &subkey_algo, &use);
3159       if (subkey_algo)
3160         {
3161           /* Create primary and subkey at once.  */
3162           both = 1;
3163           r = xmalloc_clear( sizeof *r + 20 );
3164           r->key = pKEYTYPE;
3165           sprintf( r->u.value, "%d", algo );
3166           r->next = para;
3167           para = r;
3168           nbits = ask_keysize (algo, 0);
3169           r = xmalloc_clear( sizeof *r + 20 );
3170           r->key = pKEYLENGTH;
3171           sprintf( r->u.value, "%u", nbits);
3172           r->next = para;
3173           para = r;
3174           r = xmalloc_clear( sizeof *r + 20 );
3175           r->key = pKEYUSAGE;
3176           strcpy( r->u.value, "sign" );
3177           r->next = para;
3178           para = r;
3179
3180           r = xmalloc_clear( sizeof *r + 20 );
3181           r->key = pSUBKEYTYPE;
3182           sprintf( r->u.value, "%d", subkey_algo);
3183           r->next = para;
3184           para = r;
3185           r = xmalloc_clear( sizeof *r + 20 );
3186           r->key = pSUBKEYUSAGE;
3187           strcpy( r->u.value, "encrypt" );
3188           r->next = para;
3189           para = r;
3190         }
3191       else
3192         {
3193           r = xmalloc_clear( sizeof *r + 20 );
3194           r->key = pKEYTYPE;
3195           sprintf( r->u.value, "%d", algo );
3196           r->next = para;
3197           para = r;
3198
3199           if (use)
3200             {
3201               r = xmalloc_clear( sizeof *r + 25 );
3202               r->key = pKEYUSAGE;
3203               sprintf( r->u.value, "%s%s%s",
3204                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
3205                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
3206                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
3207               r->next = para;
3208               para = r;
3209             }
3210           nbits = 0;
3211         }
3212
3213       nbits = ask_keysize (both? subkey_algo : algo, nbits);
3214       r = xmalloc_clear( sizeof *r + 20 );
3215       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
3216       sprintf( r->u.value, "%u", nbits);
3217       r->next = para;
3218       para = r;
3219     }
3220
3221   expire = ask_expire_interval(0,NULL);
3222   r = xmalloc_clear( sizeof *r + 20 );
3223   r->key = pKEYEXPIRE;
3224   r->u.expire = expire;
3225   r->next = para;
3226   para = r;
3227   r = xmalloc_clear( sizeof *r + 20 );
3228   r->key = pSUBKEYEXPIRE;
3229   r->u.expire = expire;
3230   r->next = para;
3231   para = r;
3232
3233   uid = ask_user_id (0, NULL);
3234   if( !uid )
3235     {
3236       log_error(_("Key generation canceled.\n"));
3237       release_parameter_list( para );
3238       return;
3239     }
3240   r = xmalloc_clear( sizeof *r + strlen(uid) );
3241   r->key = pUSERID;
3242   strcpy( r->u.value, uid );
3243   r->next = para;
3244   para = r;
3245
3246   canceled = 0;
3247   dek = card_serialno? NULL : do_ask_passphrase (&s2k, 0, &canceled);
3248   if( dek )
3249     {
3250       r = xmalloc_clear( sizeof *r );
3251       r->key = pPASSPHRASE_DEK;
3252       r->u.dek = dek;
3253       r->next = para;
3254       para = r;
3255       r = xmalloc_clear( sizeof *r );
3256       r->key = pPASSPHRASE_S2K;
3257       r->u.s2k = s2k;
3258       r->next = para;
3259       para = r;
3260     }
3261
3262   if (canceled)
3263     log_error (_("Key generation canceled.\n"));
3264   else
3265     proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
3266   release_parameter_list( para );
3267 }
3268
3269
3270 #ifdef ENABLE_CARD_SUPPORT
3271 /* Generate a raw key and return it as a secret key packet.  The
3272    function will ask for the passphrase and return a protected as well
3273    as an unprotected copy of a new secret key packet.  0 is returned
3274    on success and the caller must then free the returned values.  */
3275 static int
3276 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
3277                   PKT_secret_key **r_sk_unprotected,
3278                   PKT_secret_key **r_sk_protected)
3279 {
3280   int rc;
3281   DEK *dek = NULL;
3282   STRING2KEY *s2k = NULL;
3283   PKT_secret_key *sk = NULL;
3284   int i;
3285   size_t nskey, npkey;
3286   gcry_sexp_t s_parms, s_key;
3287   int canceled;
3288
3289   npkey = pubkey_get_npkey (algo);
3290   nskey = pubkey_get_nskey (algo);
3291   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
3292
3293   if (nbits < 512)
3294     {
3295       nbits = 512;
3296       log_info (_("keysize invalid; using %u bits\n"), nbits );
3297     }
3298
3299   if ((nbits % 32))
3300     {
3301       nbits = ((nbits + 31) / 32) * 32;
3302       log_info(_("keysize rounded up to %u bits\n"), nbits );
3303     }
3304
3305   dek = do_ask_passphrase (&s2k, 1, &canceled);
3306   if (canceled)
3307     {
3308       rc = gpg_error (GPG_ERR_CANCELED);
3309       goto leave;
3310     }
3311
3312   sk = xmalloc_clear (sizeof *sk);
3313   sk->timestamp = created_at;
3314   sk->version = 4;
3315   sk->pubkey_algo = algo;
3316
3317   if ( !is_RSA (algo) )
3318     {
3319       log_error ("only RSA is supported for offline generated keys\n");
3320       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3321       goto leave;
3322     }
3323   rc = gcry_sexp_build (&s_parms, NULL,
3324                         "(genkey(rsa(nbits %d)))",
3325                         (int)nbits);
3326   if (rc)
3327     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
3328   rc = gcry_pk_genkey (&s_key, s_parms);
3329   gcry_sexp_release (s_parms);
3330   if (rc)
3331     {
3332       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
3333       goto leave;
3334     }
3335   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
3336   gcry_sexp_release (s_key);
3337   if (rc)
3338     {
3339       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
3340       goto leave;
3341     }
3342
3343   for (i=npkey; i < nskey; i++)
3344     sk->csum += checksum_mpi (sk->skey[i]);
3345
3346   if (r_sk_unprotected)
3347     *r_sk_unprotected = copy_secret_key (NULL, sk);
3348
3349   rc = genhelp_protect (dek, s2k, sk);
3350   if (rc)
3351     goto leave;
3352
3353   if (r_sk_protected)
3354     {
3355       *r_sk_protected = sk;
3356       sk = NULL;
3357     }
3358
3359  leave:
3360   if (sk)
3361     free_secret_key (sk);
3362   xfree (dek);
3363   xfree (s2k);
3364   return rc;
3365 }
3366 #endif /* ENABLE_CARD_SUPPORT */
3367
3368 /* Create and delete a dummy packet to start off a list of kbnodes. */
3369 static void
3370 start_tree(KBNODE *tree)
3371 {
3372   PACKET *pkt;
3373
3374   pkt=xmalloc_clear(sizeof(*pkt));
3375   pkt->pkttype=PKT_NONE;
3376   *tree=new_kbnode(pkt);
3377   delete_kbnode(*tree);
3378 }
3379
3380
3381 static void
3382 do_generate_keypair (struct para_data_s *para,
3383                      struct output_control_s *outctrl, int card)
3384 {
3385   KBNODE pub_root = NULL;
3386   KBNODE sec_root = NULL;
3387   PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3388   const char *s;
3389   struct revocation_key *revkey;
3390   int rc;
3391   int did_sub = 0;
3392   u32 timestamp;
3393
3394   if( outctrl->dryrun )
3395     {
3396       log_info("dry-run mode - key generation skipped\n");
3397       return;
3398     }
3399
3400   if ( outctrl->use_files )
3401     {
3402       if ( outctrl->pub.newfname )
3403         {
3404           iobuf_close(outctrl->pub.stream);
3405           outctrl->pub.stream = NULL;
3406           if (outctrl->pub.fname)
3407             iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
3408           xfree( outctrl->pub.fname );
3409           outctrl->pub.fname =  outctrl->pub.newfname;
3410           outctrl->pub.newfname = NULL;
3411
3412           if (is_secured_filename (outctrl->pub.fname) )
3413             {
3414               outctrl->pub.stream = NULL;
3415               errno = EPERM;
3416             }
3417           else
3418             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
3419           if (!outctrl->pub.stream)
3420             {
3421               log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
3422                         strerror(errno) );
3423               return;
3424             }
3425           if (opt.armor)
3426             {
3427               outctrl->pub.afx->what = 1;
3428               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
3429             }
3430         }
3431       if (outctrl->sec.newfname)
3432         {
3433           mode_t oldmask;
3434
3435           iobuf_close(outctrl->sec.stream);
3436           outctrl->sec.stream = NULL;
3437           if (outctrl->sec.fname)
3438             iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
3439           xfree( outctrl->sec.fname );
3440           outctrl->sec.fname =  outctrl->sec.newfname;
3441           outctrl->sec.newfname = NULL;
3442
3443           oldmask = umask (077);
3444           if (is_secured_filename (outctrl->sec.fname) )
3445             {
3446               outctrl->sec.stream = NULL;
3447               errno = EPERM;
3448             }
3449           else
3450             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
3451           umask (oldmask);
3452           if (!outctrl->sec.stream)
3453             {
3454               log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
3455                         strerror(errno) );
3456               return;
3457             }
3458           if (opt.armor)
3459             {
3460               outctrl->sec.afx->what = 5;
3461               push_armor_filter (outctrl->sec.afx, outctrl->sec.stream);
3462             }
3463         }
3464       assert( outctrl->pub.stream );
3465       assert( outctrl->sec.stream );
3466       if (opt.verbose)
3467         {
3468           log_info (_("writing public key to `%s'\n"), outctrl->pub.fname );
3469           if (card)
3470             log_info (_("writing secret key stub to `%s'\n"),
3471                       outctrl->sec.fname);
3472           else
3473             log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
3474         }
3475     }
3476
3477
3478   /* We create the packets as a tree of kbnodes.  Because the
3479      structure we create is known in advance we simply generate a
3480      linked list.  The first packet is a dummy packet which we flag as
3481      deleted.  The very first packet must always be a KEY packet.  */
3482
3483   start_tree (&pub_root);
3484   start_tree (&sec_root);
3485
3486   timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
3487   if (!timestamp)
3488     timestamp = make_timestamp ();
3489
3490   /* Note that, depending on the backend (i.e. the used scdaemon
3491      version), the card key generation may update TIMESTAMP for each
3492      key.  Thus we need to pass TIMESTAMP to all signing function to
3493      make sure that the binding signature is done using the timestamp
3494      of the corresponding (sub)key and not that of the primary key.
3495      An alternative implementation could tell the signing function the
3496      node of the subkey but that is more work than just to pass the
3497      current timestamp.  */
3498
3499   if (!card)
3500     {
3501       rc = do_create (get_parameter_algo( para, pKEYTYPE, NULL ),
3502                       get_parameter_uint( para, pKEYLENGTH ),
3503                       pub_root, sec_root,
3504                       get_parameter_dek( para, pPASSPHRASE_DEK ),
3505                       get_parameter_s2k( para, pPASSPHRASE_S2K ),
3506                       &pri_sk,
3507                       timestamp,
3508                       get_parameter_u32( para, pKEYEXPIRE ), 0 );
3509     }
3510   else
3511     {
3512       rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root, NULL,
3513                          &timestamp,
3514                          get_parameter_u32 (para, pKEYEXPIRE), para);
3515       if (!rc)
3516         {
3517           pri_sk = sec_root->next->pkt->pkt.secret_key;
3518           assert (pri_sk);
3519         }
3520     }
3521
3522   if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
3523     {
3524       rc = write_direct_sig (pub_root, pub_root, pri_sk, revkey, timestamp);
3525       if (!rc)
3526         rc = write_direct_sig (sec_root, pub_root, pri_sk, revkey, timestamp);
3527     }
3528
3529   if( !rc && (s=get_parameter_value(para, pUSERID)) )
3530     {
3531       write_uid (pub_root, s );
3532       write_uid (sec_root, s );
3533
3534       rc = write_selfsigs (sec_root, pub_root, pri_sk,
3535                            get_parameter_uint (para, pKEYUSAGE), timestamp);
3536     }
3537
3538   /* Write the auth key to the card before the encryption key.  This
3539      is a partial workaround for a PGP bug (as of this writing, all
3540      versions including 8.1), that causes it to try and encrypt to
3541      the most recent subkey regardless of whether that subkey is
3542      actually an encryption type.  In this case, the auth key is an
3543      RSA key so it succeeds. */
3544
3545   if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
3546     {
3547       rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root, NULL,
3548                          &timestamp,
3549                          get_parameter_u32 (para, pKEYEXPIRE), para);
3550
3551       if (!rc)
3552         rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk,
3553                                PUBKEY_USAGE_AUTH, timestamp);
3554       if (!rc)
3555         rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk,
3556                                PUBKEY_USAGE_AUTH, timestamp);
3557     }
3558
3559   if( !rc && get_parameter( para, pSUBKEYTYPE ) )
3560     {
3561       if (!card)
3562         {
3563           rc = do_create( get_parameter_algo( para, pSUBKEYTYPE, NULL ),
3564                           get_parameter_uint( para, pSUBKEYLENGTH ),
3565                           pub_root, sec_root,
3566                           get_parameter_dek( para, pPASSPHRASE_DEK ),
3567                           get_parameter_s2k( para, pPASSPHRASE_S2K ),
3568                           &sub_sk,
3569                           timestamp,
3570                           get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
3571         }
3572       else
3573         {
3574           if ((s = get_parameter_value (para, pBACKUPENCDIR)))
3575             {
3576               /* A backup of the encryption key has been requested.
3577                  Generate the key in software and import it then to
3578                  the card.  Write a backup file. */
3579               rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
3580                                              pub_root, sec_root,
3581                                              timestamp,
3582                                              get_parameter_u32 (para,
3583                                                                 pKEYEXPIRE),
3584                                              para, s);
3585             }
3586           else
3587             {
3588               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
3589                                  NULL,
3590                                  &timestamp,
3591                                  get_parameter_u32 (para, pKEYEXPIRE), para);
3592             }
3593         }
3594
3595       if( !rc )
3596         rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
3597                               get_parameter_uint (para, pSUBKEYUSAGE),
3598                               timestamp);
3599       if( !rc )
3600         rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
3601                               get_parameter_uint (para, pSUBKEYUSAGE),
3602                               timestamp);
3603       did_sub = 1;
3604     }
3605
3606   if (!rc && outctrl->use_files)  /* Direct write to specified files.  */
3607     {
3608       rc = write_keyblock( outctrl->pub.stream, pub_root );
3609       if (rc)
3610         log_error ("can't write public key: %s\n", g10_errstr(rc) );
3611       if (!rc)
3612         {
3613           rc = write_keyblock( outctrl->sec.stream, sec_root );
3614           if(rc)
3615             log_error ("can't write secret key: %s\n", g10_errstr(rc) );
3616         }
3617     }
3618   else if (!rc) /* Write to the standard keyrings.  */
3619     {
3620       KEYDB_HANDLE pub_hd = keydb_new (0);
3621       KEYDB_HANDLE sec_hd = keydb_new (1);
3622
3623       rc = keydb_locate_writable (pub_hd, NULL);
3624       if (rc)
3625         log_error (_("no writable public keyring found: %s\n"),
3626                    g10_errstr (rc));
3627
3628       if (!rc)
3629         {
3630           rc = keydb_locate_writable (sec_hd, NULL);
3631           if (rc)
3632             log_error (_("no writable secret keyring found: %s\n"),
3633                        g10_errstr (rc));
3634         }
3635
3636       if (!rc && opt.verbose)
3637         {
3638           log_info (_("writing public key to `%s'\n"),
3639                     keydb_get_resource_name (pub_hd));
3640           if (card)
3641             log_info (_("writing secret key stub to `%s'\n"),
3642                       keydb_get_resource_name (sec_hd));
3643           else
3644             log_info (_("writing secret key to `%s'\n"),
3645                       keydb_get_resource_name (sec_hd));
3646         }
3647
3648       if (!rc)
3649         {
3650           rc = keydb_insert_keyblock (pub_hd, pub_root);