gpg: Allow setting of all zero key flags
[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 < 512)
1174     {
1175       nbits = 2048;
1176       log_info (_("keysize invalid; using %u bits\n"), nbits );
1177     }
1178
1179   if ((nbits % 32))
1180     {
1181       nbits = ((nbits + 31) / 32) * 32;
1182       log_info (_("keysize rounded up to %u bits\n"), nbits );
1183     }
1184
1185
1186   rc = gcry_sexp_build ( &s_parms, NULL,
1187                          "(genkey(%s(nbits %d)))",
1188                          algo == GCRY_PK_ELG_E ? "openpgp-elg" :
1189                          algo == GCRY_PK_ELG     ? "elg" : "x-oops" ,
1190                          (int)nbits);
1191   if (rc)
1192     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
1193
1194   rc = gcry_pk_genkey (&s_key, s_parms);
1195   gcry_sexp_release (s_parms);
1196   if (rc)
1197     {
1198       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
1199       return rc;
1200     }
1201
1202   sk = xmalloc_clear( sizeof *sk );
1203   pk = xmalloc_clear( sizeof *pk );
1204   sk->timestamp = pk->timestamp = timestamp;
1205   sk->version = pk->version = 4;
1206   if (expireval)
1207     {
1208       sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1209     }
1210   sk->pubkey_algo = pk->pubkey_algo = algo;
1211
1212   rc = key_from_sexp (pk->pkey, s_key, "public-key", "pgy");
1213   if (rc)
1214     {
1215       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1216       gcry_sexp_release (s_key);
1217       free_secret_key (sk);
1218       free_public_key (pk);
1219       return rc;
1220     }
1221   rc = key_from_sexp (sk->skey, s_key, "private-key", "pgyx");
1222   if (rc)
1223     {
1224       log_error("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1225       gcry_sexp_release (s_key);
1226       free_secret_key (sk);
1227       free_public_key (pk);
1228       return rc;
1229     }
1230   misc_key_info = gcry_sexp_find_token (s_key, "misc-key-info", 0);
1231   gcry_sexp_release (s_key);
1232
1233   sk->is_protected = 0;
1234   sk->protect.algo = 0;
1235
1236   sk->csum = checksum_mpi (sk->skey[3]);
1237   if (ret_sk) /* Return an unprotected version of the sk.  */
1238     *ret_sk = copy_secret_key ( NULL, sk );
1239
1240   rc = genhelp_protect (dek, s2k, sk);
1241   if (rc)
1242     {
1243       free_public_key (pk);
1244       free_secret_key (sk);
1245       gcry_sexp_release (misc_key_info);
1246       return rc;
1247     }
1248
1249   pkt = xmalloc_clear (sizeof *pkt);
1250   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1251   pkt->pkt.public_key = pk;
1252   add_kbnode (pub_root, new_kbnode( pkt ));
1253
1254   /* Don't know whether it makes sense to have access to the factors,
1255      so for now we store them in the secret keyring (but they are not
1256      secret).  */
1257   pkt = xmalloc_clear (sizeof *pkt);
1258   pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1259   pkt->pkt.secret_key = sk;
1260   add_kbnode (sec_root, new_kbnode( pkt ));
1261
1262   genhelp_factors (misc_key_info, sec_root);
1263
1264   return 0;
1265 }
1266
1267
1268 /****************
1269  * Generate a DSA key
1270  */
1271 static int
1272 gen_dsa (unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
1273          STRING2KEY *s2k, PKT_secret_key **ret_sk,
1274          u32 timestamp, u32 expireval, int is_subkey)
1275 {
1276   int rc;
1277   PACKET *pkt;
1278   PKT_secret_key *sk;
1279   PKT_public_key *pk;
1280   gcry_sexp_t s_parms, s_key;
1281   gcry_sexp_t misc_key_info;
1282   unsigned int qbits;
1283
1284   if ( nbits < 512)
1285     {
1286       nbits = 2048;
1287       log_info(_("keysize invalid; using %u bits\n"), nbits );
1288     }
1289   else if ( nbits > 3072 )
1290     {
1291       nbits = 3072;
1292       log_info(_("keysize invalid; using %u bits\n"), nbits );
1293     }
1294
1295   if( (nbits % 64) )
1296     {
1297       nbits = ((nbits + 63) / 64) * 64;
1298       log_info(_("keysize rounded up to %u bits\n"), nbits );
1299     }
1300
1301   /* To comply with FIPS rules we round up to the next value unless in
1302      expert mode.  */
1303   if (!opt.expert && nbits > 1024 && (nbits % 1024))
1304     {
1305       nbits = ((nbits + 1023) / 1024) * 1024;
1306       log_info(_("keysize rounded up to %u bits\n"), nbits );
1307     }
1308
1309   /*
1310     Figure out a q size based on the key size.  FIPS 180-3 says:
1311
1312     L = 1024, N = 160
1313     L = 2048, N = 224
1314     L = 2048, N = 256
1315     L = 3072, N = 256
1316
1317     2048/256 is an odd pair since there is also a 2048/224 and
1318     3072/256.  Matching sizes is not a very exact science.
1319
1320     We'll do 256 qbits for nbits over 2047, 224 for nbits over 1024
1321     but less than 2048, and 160 for 1024 (DSA1).
1322   */
1323
1324   if (nbits > 2047)
1325     qbits = 256;
1326   else if ( nbits > 1024)
1327     qbits = 224;
1328   else
1329     qbits = 160;
1330
1331   if (qbits != 160 )
1332     log_info (_("WARNING: some OpenPGP programs can't"
1333                 " handle a DSA key with this digest size\n"));
1334
1335   rc = gcry_sexp_build (&s_parms, NULL,
1336                         "(genkey(dsa(nbits %d)(qbits %d)))",
1337                         (int)nbits, (int)qbits);
1338   if (rc)
1339     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
1340
1341   rc = gcry_pk_genkey (&s_key, s_parms);
1342   gcry_sexp_release (s_parms);
1343   if (rc)
1344     {
1345       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
1346       return rc;
1347     }
1348
1349   sk = xmalloc_clear( sizeof *sk );
1350   pk = xmalloc_clear( sizeof *pk );
1351   sk->timestamp = pk->timestamp = timestamp;
1352   sk->version = pk->version = 4;
1353   if (expireval)
1354     sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1355   sk->pubkey_algo = pk->pubkey_algo = PUBKEY_ALGO_DSA;
1356
1357   rc = key_from_sexp (pk->pkey, s_key, "public-key", "pqgy");
1358   if (rc)
1359     {
1360       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc));
1361       gcry_sexp_release (s_key);
1362       free_public_key(pk);
1363       free_secret_key(sk);
1364       return rc;
1365     }
1366   rc = key_from_sexp (sk->skey, s_key, "private-key", "pqgyx");
1367   if (rc)
1368     {
1369       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1370       gcry_sexp_release (s_key);
1371       free_public_key(pk);
1372       free_secret_key(sk);
1373       return rc;
1374     }
1375   misc_key_info = gcry_sexp_find_token (s_key, "misc-key-info", 0);
1376   gcry_sexp_release (s_key);
1377
1378   sk->is_protected = 0;
1379   sk->protect.algo = 0;
1380
1381   sk->csum = checksum_mpi ( sk->skey[4] );
1382   if( ret_sk ) /* return an unprotected version of the sk */
1383     *ret_sk = copy_secret_key( NULL, sk );
1384
1385   rc = genhelp_protect (dek, s2k, sk);
1386   if (rc)
1387     {
1388       free_public_key (pk);
1389       free_secret_key (sk);
1390       gcry_sexp_release (misc_key_info);
1391       return rc;
1392     }
1393
1394   pkt = xmalloc_clear(sizeof *pkt);
1395   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1396   pkt->pkt.public_key = pk;
1397   add_kbnode(pub_root, new_kbnode( pkt ));
1398
1399   /* Don't know whether it makes sense to have the factors, so for now
1400    * we store them in the secret keyring (but they are not secret)
1401    * p = 2 * q * f1 * f2 * ... * fn
1402    * We store only f1 to f_n-1;  fn can be calculated because p and q
1403    * are known.
1404    */
1405   pkt = xmalloc_clear(sizeof *pkt);
1406   pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1407   pkt->pkt.secret_key = sk;
1408   add_kbnode(sec_root, new_kbnode( pkt ));
1409
1410   genhelp_factors (misc_key_info, sec_root);
1411
1412   return 0;
1413 }
1414
1415
1416 /*
1417  * Generate an RSA key.
1418  */
1419 static int
1420 gen_rsa (int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
1421          STRING2KEY *s2k, PKT_secret_key **ret_sk,
1422          u32 timestamp, u32 expireval, int is_subkey)
1423 {
1424   int rc;
1425   PACKET *pkt;
1426   PKT_secret_key *sk;
1427   PKT_public_key *pk;
1428   gcry_sexp_t s_parms, s_key;
1429
1430   assert (is_RSA(algo));
1431
1432   if (!nbits)
1433     nbits = DEFAULT_STD_KEYSIZE;
1434
1435   if (nbits < 1024)
1436     {
1437       nbits = 2048;
1438       log_info (_("keysize invalid; using %u bits\n"), nbits );
1439     }
1440
1441   if ((nbits % 32))
1442     {
1443       nbits = ((nbits + 31) / 32) * 32;
1444       log_info (_("keysize rounded up to %u bits\n"), nbits );
1445     }
1446
1447   rc = gcry_sexp_build (&s_parms, NULL,
1448                         "(genkey(rsa(nbits %d)))",
1449                         (int)nbits);
1450   if (rc)
1451     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
1452
1453   rc = gcry_pk_genkey (&s_key, s_parms);
1454   gcry_sexp_release (s_parms);
1455   if (rc)
1456     {
1457       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
1458       return rc;
1459     }
1460
1461   sk = xmalloc_clear( sizeof *sk );
1462   pk = xmalloc_clear( sizeof *pk );
1463   sk->timestamp = pk->timestamp = timestamp;
1464   sk->version = pk->version = 4;
1465   if (expireval)
1466     {
1467       sk->expiredate = pk->expiredate = sk->timestamp + expireval;
1468     }
1469   sk->pubkey_algo = pk->pubkey_algo = algo;
1470
1471   rc = key_from_sexp (pk->pkey, s_key, "public-key", "ne");
1472   if (rc)
1473     {
1474       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc));
1475       gcry_sexp_release (s_key);
1476       free_public_key(pk);
1477       free_secret_key(sk);
1478       return rc;
1479     }
1480   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
1481   if (rc)
1482     {
1483       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
1484       gcry_sexp_release (s_key);
1485       free_public_key(pk);
1486       free_secret_key(sk);
1487       return rc;
1488     }
1489   gcry_sexp_release (s_key);
1490
1491   sk->is_protected = 0;
1492   sk->protect.algo = 0;
1493
1494   sk->csum  = checksum_mpi (sk->skey[2] );
1495   sk->csum += checksum_mpi (sk->skey[3] );
1496   sk->csum += checksum_mpi (sk->skey[4] );
1497   sk->csum += checksum_mpi (sk->skey[5] );
1498   if( ret_sk ) /* return an unprotected version of the sk */
1499     *ret_sk = copy_secret_key( NULL, sk );
1500
1501   rc = genhelp_protect (dek, s2k, sk);
1502   if (rc)
1503     {
1504       free_public_key (pk);
1505       free_secret_key (sk);
1506       return rc;
1507     }
1508
1509   pkt = xmalloc_clear(sizeof *pkt);
1510   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
1511   pkt->pkt.public_key = pk;
1512   add_kbnode(pub_root, new_kbnode( pkt ));
1513
1514   pkt = xmalloc_clear(sizeof *pkt);
1515   pkt->pkttype = is_subkey ? PKT_SECRET_SUBKEY : PKT_SECRET_KEY;
1516   pkt->pkt.secret_key = sk;
1517   add_kbnode(sec_root, new_kbnode( pkt ));
1518
1519   return 0;
1520 }
1521
1522
1523 /****************
1524  * check valid days:
1525  * return 0 on error or the multiplier
1526  */
1527 static int
1528 check_valid_days( const char *s )
1529 {
1530     if( !digitp(s) )
1531         return 0;
1532     for( s++; *s; s++)
1533         if( !digitp(s) )
1534             break;
1535     if( !*s )
1536         return 1;
1537     if( s[1] )
1538         return 0; /* e.g. "2323wc" */
1539     if( *s == 'd' || *s == 'D' )
1540         return 1;
1541     if( *s == 'w' || *s == 'W' )
1542         return 7;
1543     if( *s == 'm' || *s == 'M' )
1544         return 30;
1545     if( *s == 'y' || *s == 'Y' )
1546         return 365;
1547     return 0;
1548 }
1549
1550
1551 static void
1552 print_key_flags(int flags)
1553 {
1554   if(flags&PUBKEY_USAGE_SIG)
1555     tty_printf("%s ",_("Sign"));
1556
1557   if(flags&PUBKEY_USAGE_CERT)
1558     tty_printf("%s ",_("Certify"));
1559
1560   if(flags&PUBKEY_USAGE_ENC)
1561     tty_printf("%s ",_("Encrypt"));
1562
1563   if(flags&PUBKEY_USAGE_AUTH)
1564     tty_printf("%s ",_("Authenticate"));
1565 }
1566
1567
1568 /* Returns the key flags */
1569 static unsigned int
1570 ask_key_flags(int algo,int subkey)
1571 {
1572   /* TRANSLATORS: Please use only plain ASCII characters for the
1573      translation.  If this is not possible use single digits.  The
1574      string needs to 8 bytes long. Here is a description of the
1575      functions:
1576
1577        s = Toggle signing capability
1578        e = Toggle encryption capability
1579        a = Toggle authentication capability
1580        q = Finish
1581   */
1582   const char *togglers=_("SsEeAaQq");
1583   char *answer=NULL;
1584   unsigned int current=0;
1585   unsigned int possible=openpgp_pk_algo_usage(algo);
1586
1587   if ( strlen(togglers) != 8 )
1588     {
1589       tty_printf ("NOTE: Bad translation at %s:%d. "
1590                   "Please report.\n", __FILE__, __LINE__);
1591       togglers = "11223300";
1592     }
1593
1594   /* Only primary keys may certify. */
1595   if(subkey)
1596     possible&=~PUBKEY_USAGE_CERT;
1597
1598   /* Preload the current set with the possible set, minus
1599      authentication, since nobody really uses auth yet. */
1600   current=possible&~PUBKEY_USAGE_AUTH;
1601
1602   for(;;)
1603     {
1604       tty_printf("\n");
1605       tty_printf(_("Possible actions for a %s key: "),
1606                  gcry_pk_algo_name (algo));
1607       print_key_flags(possible);
1608       tty_printf("\n");
1609       tty_printf(_("Current allowed actions: "));
1610       print_key_flags(current);
1611       tty_printf("\n\n");
1612
1613       if(possible&PUBKEY_USAGE_SIG)
1614         tty_printf(_("   (%c) Toggle the sign capability\n"),
1615                    togglers[0]);
1616       if(possible&PUBKEY_USAGE_ENC)
1617         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
1618                    togglers[2]);
1619       if(possible&PUBKEY_USAGE_AUTH)
1620         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
1621                    togglers[4]);
1622
1623       tty_printf(_("   (%c) Finished\n"),togglers[6]);
1624       tty_printf("\n");
1625
1626       xfree(answer);
1627       answer = cpr_get("keygen.flags",_("Your selection? "));
1628       cpr_kill_prompt();
1629
1630       if(strlen(answer)>1)
1631         tty_printf(_("Invalid selection.\n"));
1632       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
1633         break;
1634       else if((*answer==togglers[0] || *answer==togglers[1])
1635               && possible&PUBKEY_USAGE_SIG)
1636         {
1637           if(current&PUBKEY_USAGE_SIG)
1638             current&=~PUBKEY_USAGE_SIG;
1639           else
1640             current|=PUBKEY_USAGE_SIG;
1641         }
1642       else if((*answer==togglers[2] || *answer==togglers[3])
1643               && possible&PUBKEY_USAGE_ENC)
1644         {
1645           if(current&PUBKEY_USAGE_ENC)
1646             current&=~PUBKEY_USAGE_ENC;
1647           else
1648             current|=PUBKEY_USAGE_ENC;
1649         }
1650       else if((*answer==togglers[4] || *answer==togglers[5])
1651               && possible&PUBKEY_USAGE_AUTH)
1652         {
1653           if(current&PUBKEY_USAGE_AUTH)
1654             current&=~PUBKEY_USAGE_AUTH;
1655           else
1656             current|=PUBKEY_USAGE_AUTH;
1657         }
1658       else
1659         tty_printf(_("Invalid selection.\n"));
1660     }
1661
1662   xfree(answer);
1663
1664   return current;
1665 }
1666
1667
1668 /* Ask for an algorithm.  The function returns the algorithm id to
1669  * create. If ADDMODE is false the function won't show an option to
1670  * create the primary and subkey combined and won't set R_USAGE
1671  * either.  If a combined algorithm has been selected, the subkey
1672  * algorithm is stored at R_SUBKEY_ALGO.  */
1673 static int
1674 ask_algo (int addmode, int *r_subkey_algo, unsigned int *r_usage)
1675 {
1676   char *answer;
1677   int algo;
1678   int dummy_algo;
1679
1680   if (!r_subkey_algo)
1681     r_subkey_algo = &dummy_algo;
1682
1683   tty_printf (_("Please select what kind of key you want:\n"));
1684
1685   if (!addmode)
1686     tty_printf (_("   (%d) RSA and RSA (default)\n"), 1 );
1687   if (!addmode)
1688     tty_printf (_("   (%d) DSA and Elgamal\n"), 2 );
1689
1690   tty_printf (_("   (%d) DSA (sign only)\n"), 3 );
1691   tty_printf (_("   (%d) RSA (sign only)\n"), 4 );
1692
1693   if (addmode)
1694     {
1695       tty_printf (_("   (%d) Elgamal (encrypt only)\n"), 5 );
1696       tty_printf (_("   (%d) RSA (encrypt only)\n"), 6 );
1697     }
1698   if (opt.expert)
1699     {
1700       tty_printf (_("   (%d) DSA (set your own capabilities)\n"), 7 );
1701       tty_printf (_("   (%d) RSA (set your own capabilities)\n"), 8 );
1702     }
1703
1704   for(;;)
1705     {
1706       *r_usage = 0;
1707       *r_subkey_algo = 0;
1708       answer = cpr_get ("keygen.algo", _("Your selection? "));
1709       cpr_kill_prompt ();
1710       algo = *answer? atoi (answer) : 1;
1711       xfree(answer);
1712       if (algo == 1 && !addmode)
1713         {
1714           algo = PUBKEY_ALGO_RSA;
1715           *r_subkey_algo = PUBKEY_ALGO_RSA;
1716           break;
1717         }
1718       else if (algo == 2 && !addmode)
1719         {
1720           algo = PUBKEY_ALGO_DSA;
1721           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
1722           break;
1723         }
1724       else if (algo == 3)
1725         {
1726           algo = PUBKEY_ALGO_DSA;
1727           *r_usage = PUBKEY_USAGE_SIG;
1728           break;
1729         }
1730       else if (algo == 4)
1731         {
1732           algo = PUBKEY_ALGO_RSA;
1733           *r_usage = PUBKEY_USAGE_SIG;
1734           break;
1735         }
1736       else if (algo == 5 && addmode)
1737         {
1738           algo = PUBKEY_ALGO_ELGAMAL_E;
1739           *r_usage = PUBKEY_USAGE_ENC;
1740           break;
1741         }
1742       else if (algo == 6 && addmode)
1743         {
1744           algo = PUBKEY_ALGO_RSA;
1745           *r_usage = PUBKEY_USAGE_ENC;
1746           break;
1747         }
1748       else if (algo == 7 && opt.expert)
1749         {
1750           algo = PUBKEY_ALGO_DSA;
1751           *r_usage = ask_key_flags (algo, addmode);
1752           break;
1753         }
1754       else if (algo == 8 && opt.expert)
1755         {
1756           algo = PUBKEY_ALGO_RSA;
1757           *r_usage = ask_key_flags (algo, addmode);
1758           break;
1759         }
1760       else
1761         tty_printf (_("Invalid selection.\n"));
1762     }
1763
1764   return algo;
1765 }
1766
1767
1768 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
1769    is not 0, the function asks for the size of the encryption
1770    subkey. */
1771 static unsigned
1772 ask_keysize (int algo, unsigned int primary_keysize)
1773 {
1774   unsigned int nbits, min, def = DEFAULT_STD_KEYSIZE, max=4096;
1775   int for_subkey = !!primary_keysize;
1776   int autocomp = 0;
1777
1778   if(opt.expert)
1779     min=512;
1780   else
1781     min=1024;
1782
1783   if (primary_keysize && !opt.expert)
1784     {
1785       /* Deduce the subkey size from the primary key size.  */
1786       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
1787         nbits = 3072; /* For performance reasons we don't support more
1788                          than 3072 bit DSA.  However we won't see this
1789                          case anyway because DSA can't be used as an
1790                          encryption subkey ;-). */
1791       else
1792         nbits = primary_keysize;
1793       autocomp = 1;
1794       goto leave;
1795     }
1796
1797   switch(algo)
1798     {
1799     case PUBKEY_ALGO_DSA:
1800       def=2048;
1801       max=3072;
1802       break;
1803
1804     case PUBKEY_ALGO_RSA:
1805       min=1024;
1806       break;
1807     }
1808
1809   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
1810              gcry_pk_algo_name (algo), min, max);
1811
1812   for(;;)
1813     {
1814       char *prompt, *answer;
1815
1816       if (for_subkey)
1817         prompt = xasprintf (_("What keysize do you want "
1818                               "for the subkey? (%u) "), def);
1819       else
1820         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
1821       answer = cpr_get ("keygen.size", prompt);
1822       cpr_kill_prompt ();
1823       nbits = *answer? atoi (answer): def;
1824       xfree(prompt);
1825       xfree(answer);
1826
1827       if(nbits<min || nbits>max)
1828         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
1829                    gcry_pk_algo_name (algo), min, max);
1830       else
1831         break;
1832     }
1833
1834   tty_printf(_("Requested keysize is %u bits\n"), nbits );
1835
1836  leave:
1837   if( algo == PUBKEY_ALGO_DSA && (nbits % 64) )
1838     {
1839       nbits = ((nbits + 63) / 64) * 64;
1840       if (!autocomp)
1841         tty_printf(_("rounded up to %u bits\n"), nbits );
1842     }
1843   else if( (nbits % 32) )
1844     {
1845       nbits = ((nbits + 31) / 32) * 32;
1846       if (!autocomp)
1847         tty_printf(_("rounded up to %u bits\n"), nbits );
1848     }
1849
1850   return nbits;
1851 }
1852
1853
1854 /****************
1855  * Parse an expire string and return its value in seconds.
1856  * Returns (u32)-1 on error.
1857  * This isn't perfect since scan_isodatestr returns unix time, and
1858  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
1859  * Because of this, we only permit setting expirations up to 2106, but
1860  * OpenPGP could theoretically allow up to 2242.  I think we'll all
1861  * just cope for the next few years until we get a 64-bit time_t or
1862  * similar.
1863  */
1864 u32
1865 parse_expire_string( const char *string )
1866 {
1867   int mult;
1868   u32 seconds;
1869   u32 abs_date = 0;
1870   u32 curtime = make_timestamp ();
1871   time_t tt;
1872
1873   if (!*string)
1874     seconds = 0;
1875   else if (!strncmp (string, "seconds=", 8))
1876     seconds = atoi (string+8);
1877   else if ((abs_date = scan_isodatestr(string))
1878            && (abs_date+86400/2) > curtime)
1879     seconds = (abs_date+86400/2) - curtime;
1880   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
1881     seconds = (u32)tt - curtime;
1882   else if ((mult = check_valid_days (string)))
1883     seconds = atoi (string) * 86400L * mult;
1884   else
1885     seconds = (u32)(-1);
1886
1887   return seconds;
1888 }
1889
1890 /* Parsean Creation-Date string which is either "1986-04-26" or
1891    "19860426T042640".  Returns 0 on error. */
1892 static u32
1893 parse_creation_string (const char *string)
1894 {
1895   u32 seconds;
1896
1897   if (!*string)
1898     seconds = 0;
1899   else if ( !strncmp (string, "seconds=", 8) )
1900     seconds = atoi (string+8);
1901   else if ( !(seconds = scan_isodatestr (string)))
1902     {
1903       time_t tmp = isotime2epoch (string);
1904       seconds = (tmp == (time_t)(-1))? 0 : tmp;
1905     }
1906   return seconds;
1907 }
1908
1909
1910 /* object == 0 for a key, and 1 for a sig */
1911 u32
1912 ask_expire_interval(int object,const char *def_expire)
1913 {
1914     u32 interval;
1915     char *answer;
1916
1917     switch(object)
1918       {
1919       case 0:
1920         if(def_expire)
1921           BUG();
1922         tty_printf(_("Please specify how long the key should be valid.\n"
1923                      "         0 = key does not expire\n"
1924                      "      <n>  = key expires in n days\n"
1925                      "      <n>w = key expires in n weeks\n"
1926                      "      <n>m = key expires in n months\n"
1927                      "      <n>y = key expires in n years\n"));
1928         break;
1929
1930       case 1:
1931         if(!def_expire)
1932           BUG();
1933         tty_printf(_("Please specify how long the signature should be valid.\n"
1934                      "         0 = signature does not expire\n"
1935                      "      <n>  = signature expires in n days\n"
1936                      "      <n>w = signature expires in n weeks\n"
1937                      "      <n>m = signature expires in n months\n"
1938                      "      <n>y = signature expires in n years\n"));
1939         break;
1940
1941       default:
1942         BUG();
1943       }
1944
1945     /* Note: The elgamal subkey for DSA has no expiration date because
1946      * it must be signed with the DSA key and this one has the expiration
1947      * date */
1948
1949     answer = NULL;
1950     for(;;)
1951       {
1952         u32 curtime=make_timestamp();
1953
1954         xfree(answer);
1955         if(object==0)
1956           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1957         else
1958           {
1959             char *prompt;
1960
1961 #define PROMPTSTRING _("Signature is valid for? (%s) ")
1962             /* This will actually end up larger than necessary because
1963                of the 2 bytes for '%s' */
1964             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
1965             sprintf(prompt,PROMPTSTRING,def_expire);
1966 #undef PROMPTSTRING
1967
1968             answer = cpr_get("siggen.valid",prompt);
1969             xfree(prompt);
1970
1971             if(*answer=='\0')
1972               answer=xstrdup(def_expire);
1973           }
1974         cpr_kill_prompt();
1975         trim_spaces(answer);
1976         interval = parse_expire_string( answer );
1977         if( interval == (u32)-1 )
1978           {
1979             tty_printf(_("invalid value\n"));
1980             continue;
1981           }
1982
1983         if( !interval )
1984           {
1985             tty_printf((object==0)
1986                        ? _("Key does not expire at all\n")
1987                        : _("Signature does not expire at all\n"));
1988           }
1989         else
1990           {
1991             tty_printf(object==0
1992                        ? _("Key expires at %s\n")
1993                        : _("Signature expires at %s\n"),
1994                        asctimestamp((ulong)(curtime + interval) ) );
1995 #if SIZEOF_TIME_T <= 4
1996             if ( (time_t)((ulong)(curtime+interval)) < 0 )
1997               tty_printf (_("Your system can't display dates beyond 2038.\n"
1998                             "However, it will be correctly handled up to"
1999                             " 2106.\n"));
2000             else
2001 #endif /*SIZEOF_TIME_T*/
2002               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
2003                 {
2004                   tty_printf (_("invalid value\n"));
2005                   continue;
2006                 }
2007           }
2008
2009         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
2010                                                    _("Is this correct? (y/N) ")) )
2011           break;
2012       }
2013
2014     xfree(answer);
2015     return interval;
2016 }
2017
2018 u32
2019 ask_expiredate()
2020 {
2021     u32 x = ask_expire_interval(0,NULL);
2022     return x? make_timestamp() + x : 0;
2023 }
2024
2025
2026
2027 static PKT_user_id *
2028 uid_from_string (const char *string)
2029 {
2030   size_t n;
2031   PKT_user_id *uid;
2032
2033   n = strlen (string);
2034   uid = xmalloc_clear (sizeof *uid + n);
2035   uid->len = n;
2036   strcpy (uid->name, string);
2037   uid->ref = 1;
2038   return uid;
2039 }
2040
2041
2042 /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
2043    printed for use during a new key creation.  If KEYBLOCK is not NULL
2044    the function prevents the creation of an already existing user
2045    ID.  */
2046 static char *
2047 ask_user_id (int mode, KBNODE keyblock)
2048 {
2049     char *answer;
2050     char *aname, *acomment, *amail, *uid;
2051
2052     if ( !mode )
2053       {
2054         /* TRANSLATORS: This is the new string telling the user what
2055            gpg is now going to do (i.e. ask for the parts of the user
2056            ID).  Note that if you do not tyranslated this string, a
2057            different string will be used used, which might still have
2058            a correct transaltion.  */
2059         const char *s1 =
2060           N_("\n"
2061              "GnuPG needs to construct a user ID to identify your key.\n"
2062              "\n");
2063         const char *s2 = _(s1);
2064
2065         if (!strcmp (s1, s2))
2066           {
2067             /* There is no translation for the string thus we to use
2068                the old info text.  gettext has no way to tell whether
2069                a translation is actually available, thus we need to
2070                to compare again. */
2071             /* TRANSLATORS: This string is in general not anymore used
2072                but you should keep your existing translation.  In case
2073                the new string is not translated this old string will
2074                be used. */
2075             const char *s3 = N_("\n"
2076 "You need a user ID to identify your key; "
2077                                         "the software constructs the user ID\n"
2078 "from the Real Name, Comment and Email Address in this form:\n"
2079 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
2080             const char *s4 = _(s3);
2081             if (strcmp (s3, s4))
2082               s2 = s3; /* A translation exists - use it. */
2083           }
2084         tty_printf ("%s", s2) ;
2085       }
2086     uid = aname = acomment = amail = NULL;
2087     for(;;) {
2088         char *p;
2089         int fail=0;
2090
2091         if( !aname ) {
2092             for(;;) {
2093                 xfree(aname);
2094                 aname = cpr_get("keygen.name",_("Real name: "));
2095                 trim_spaces(aname);
2096                 cpr_kill_prompt();
2097
2098                 if( opt.allow_freeform_uid )
2099                     break;
2100
2101                 if( strpbrk( aname, "<>" ) )
2102                     tty_printf(_("Invalid character in name\n"));
2103                 else if( digitp(aname) )
2104                     tty_printf(_("Name may not start with a digit\n"));
2105                 else if( strlen(aname) < 5 )
2106                     tty_printf(_("Name must be at least 5 characters long\n"));
2107                 else
2108                     break;
2109             }
2110         }
2111         if( !amail ) {
2112             for(;;) {
2113                 xfree(amail);
2114                 amail = cpr_get("keygen.email",_("Email address: "));
2115                 trim_spaces(amail);
2116                 cpr_kill_prompt();
2117                 if( !*amail || opt.allow_freeform_uid )
2118                     break;   /* no email address is okay */
2119                 else if ( !is_valid_mailbox (amail) )
2120                     tty_printf(_("Not a valid email address\n"));
2121                 else
2122                     break;
2123             }
2124         }
2125         if( !acomment ) {
2126             for(;;) {
2127                 xfree(acomment);
2128                 acomment = cpr_get("keygen.comment",_("Comment: "));
2129                 trim_spaces(acomment);
2130                 cpr_kill_prompt();
2131                 if( !*acomment )
2132                     break;   /* no comment is okay */
2133                 else if( strpbrk( acomment, "()" ) )
2134                     tty_printf(_("Invalid character in comment\n"));
2135                 else
2136                     break;
2137             }
2138         }
2139
2140
2141         xfree(uid);
2142         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
2143         p = stpcpy(p, aname );
2144         if( *acomment )
2145             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
2146         if( *amail )
2147             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
2148
2149         /* Append a warning if the RNG is switched into fake mode.  */
2150         if ( random_is_faked ()  )
2151           strcpy(p, " (insecure!)" );
2152
2153         /* print a note in case that UTF8 mapping has to be done */
2154         for(p=uid; *p; p++ ) {
2155             if( *p & 0x80 ) {
2156                 tty_printf(_("You are using the `%s' character set.\n"),
2157                            get_native_charset() );
2158                 break;
2159             }
2160         }
2161
2162         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
2163
2164         if( !*amail && !opt.allow_freeform_uid
2165             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
2166             fail = 1;
2167             tty_printf(_("Please don't put the email address "
2168                          "into the real name or the comment\n") );
2169         }
2170
2171         if (!fail && keyblock)
2172           {
2173             PKT_user_id *uidpkt = uid_from_string (uid);
2174             KBNODE node;
2175
2176             for (node=keyblock; node && !fail; node=node->next)
2177               if (!is_deleted_kbnode (node)
2178                   && node->pkt->pkttype == PKT_USER_ID
2179                   && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
2180                 fail = 1;
2181             if (fail)
2182               tty_printf (_("Such a user ID already exists on this key!\n"));
2183             free_user_id (uidpkt);
2184           }
2185
2186         for(;;) {
2187             /* TRANSLATORS: These are the allowed answers in
2188                lower and uppercase.  Below you will find the matching
2189                string which should be translated accordingly and the
2190                letter changed to match the one in the answer string.
2191
2192                  n = Change name
2193                  c = Change comment
2194                  e = Change email
2195                  o = Okay (ready, continue)
2196                  q = Quit
2197              */
2198             const char *ansstr = _("NnCcEeOoQq");
2199
2200             if( strlen(ansstr) != 10 )
2201                 BUG();
2202             if( cpr_enabled() ) {
2203                 answer = xstrdup (ansstr + (fail?8:6));
2204                 answer[1] = 0;
2205             }
2206             else {
2207                 answer = cpr_get("keygen.userid.cmd", fail?
2208                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
2209                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
2210                 cpr_kill_prompt();
2211             }
2212             if( strlen(answer) > 1 )
2213                 ;
2214             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
2215                 xfree(aname); aname = NULL;
2216                 break;
2217             }
2218             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
2219                 xfree(acomment); acomment = NULL;
2220                 break;
2221             }
2222             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
2223                 xfree(amail); amail = NULL;
2224                 break;
2225             }
2226             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
2227                 if( fail ) {
2228                     tty_printf(_("Please correct the error first\n"));
2229                 }
2230                 else {
2231                     xfree(aname); aname = NULL;
2232                     xfree(acomment); acomment = NULL;
2233                     xfree(amail); amail = NULL;
2234                     break;
2235                 }
2236             }
2237             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
2238                 xfree(aname); aname = NULL;
2239                 xfree(acomment); acomment = NULL;
2240                 xfree(amail); amail = NULL;
2241                 xfree(uid); uid = NULL;
2242                 break;
2243             }
2244             xfree(answer);
2245         }
2246         xfree(answer);
2247         if( !aname && !acomment && !amail )
2248             break;
2249         xfree(uid); uid = NULL;
2250     }
2251     if( uid ) {
2252         char *p = native_to_utf8( uid );
2253         xfree( uid );
2254         uid = p;
2255     }
2256     return uid;
2257 }
2258
2259
2260 /*  MODE  0 - standard
2261           1 - Ask for passphrase of the card backup key.  */
2262 static DEK *
2263 do_ask_passphrase (STRING2KEY **ret_s2k, int mode, int *r_canceled)
2264 {
2265     DEK *dek = NULL;
2266     STRING2KEY *s2k;
2267     const char *errtext = NULL;
2268     const char *custdesc = NULL;
2269
2270     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
2271
2272     if (mode == 1)
2273       custdesc = _("Please enter a passphrase to protect the off-card "
2274                    "backup of the new encryption key.");
2275
2276     s2k = xmalloc_secure( sizeof *s2k );
2277     for(;;) {
2278         s2k->mode = opt.s2k_mode;
2279         s2k->hash_algo = S2K_DIGEST_ALGO;
2280         dek = passphrase_to_dek_ext (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2281                                      errtext, custdesc, NULL, r_canceled);
2282         if (!dek && *r_canceled) {
2283             xfree(dek); dek = NULL;
2284             xfree(s2k); s2k = NULL;
2285             break;
2286         }
2287         else if( !dek ) {
2288             errtext = N_("passphrase not correctly repeated; try again");
2289             tty_printf(_("%s.\n"), _(errtext));
2290         }
2291         else if( !dek->keylen ) {
2292             xfree(dek); dek = NULL;
2293             xfree(s2k); s2k = NULL;
2294             tty_printf(_(
2295             "You don't want a passphrase - this is probably a *bad* idea!\n"
2296             "I will do it anyway.  You can change your passphrase at any time,\n"
2297             "using this program with the option \"--edit-key\".\n\n"));
2298             break;
2299         }
2300         else
2301             break; /* okay */
2302     }
2303     *ret_s2k = s2k;
2304     return dek;
2305 }
2306
2307
2308 /* Basic key generation.  Here we divert to the actual generation
2309    routines based on the requested algorithm.  */
2310 static int
2311 do_create (int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
2312            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk,
2313            u32 timestamp, u32 expiredate, int is_subkey )
2314 {
2315   int rc=0;
2316
2317   if( !opt.batch )
2318     tty_printf(_(
2319 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2320 "some other action (type on the keyboard, move the mouse, utilize the\n"
2321 "disks) during the prime generation; this gives the random number\n"
2322 "generator a better chance to gain enough entropy.\n") );
2323
2324   if( algo == PUBKEY_ALGO_ELGAMAL_E )
2325     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk,
2326                  timestamp, expiredate, is_subkey);
2327   else if( algo == PUBKEY_ALGO_DSA )
2328     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk,
2329                  timestamp, expiredate, is_subkey);
2330   else if( algo == PUBKEY_ALGO_RSA )
2331     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk,
2332                  timestamp, expiredate, is_subkey);
2333   else
2334     BUG();
2335
2336   return rc;
2337 }
2338
2339
2340 /* Generate a new user id packet or return NULL if canceled.  If
2341    KEYBLOCK is not NULL the function prevents the creation of an
2342    already existing user ID.  */
2343 PKT_user_id *
2344 generate_user_id (KBNODE keyblock)
2345 {
2346   char *p;
2347
2348   p = ask_user_id (1, keyblock);
2349   if (!p)
2350     return NULL;  /* Canceled. */
2351   return uid_from_string (p);
2352 }
2353
2354
2355 static void
2356 release_parameter_list( struct para_data_s *r )
2357 {
2358     struct para_data_s *r2;
2359
2360     for( ; r ; r = r2 ) {
2361         r2 = r->next;
2362         if( r->key == pPASSPHRASE_DEK )
2363             xfree( r->u.dek );
2364         else if( r->key == pPASSPHRASE_S2K )
2365             xfree( r->u.s2k );
2366
2367         xfree(r);
2368     }
2369 }
2370
2371 static struct para_data_s *
2372 get_parameter( struct para_data_s *para, enum para_name key )
2373 {
2374     struct para_data_s *r;
2375
2376     for( r = para; r && r->key != key; r = r->next )
2377         ;
2378     return r;
2379 }
2380
2381 static const char *
2382 get_parameter_value( struct para_data_s *para, enum para_name key )
2383 {
2384     struct para_data_s *r = get_parameter( para, key );
2385     return (r && *r->u.value)? r->u.value : NULL;
2386 }
2387
2388 static int
2389 get_parameter_algo( struct para_data_s *para, enum para_name key,
2390                     int *r_default)
2391 {
2392   int i;
2393   struct para_data_s *r = get_parameter( para, key );
2394
2395   if (r_default)
2396     *r_default = 0;
2397
2398   if (!r)
2399     return -1;
2400
2401   if (!ascii_strcasecmp (r->u.value, "default"))
2402     {
2403       /* Note: If you change this default algo, remember to change it
2404          also in gpg.c:gpgconf_list.  */
2405       i = DEFAULT_STD_ALGO;
2406       if (r_default)
2407         *r_default = 1;
2408     }
2409   else if (digitp (r->u.value))
2410     i = atoi( r->u.value );
2411   else if (!strcmp (r->u.value, "ELG-E")
2412            || !strcmp (r->u.value, "ELG"))
2413     i = GCRY_PK_ELG_E;
2414   else
2415     i = gcry_pk_map_name (r->u.value);
2416
2417   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2418     i = 0; /* we don't want to allow generation of these algorithms */
2419   return i;
2420 }
2421
2422 /*
2423  * Parse the usage parameter and set the keyflags.  Returns -1 on
2424  * error, 0 for no usage given or 1 for usage available.
2425  */
2426 static int
2427 parse_parameter_usage (const char *fname,
2428                        struct para_data_s *para, enum para_name key)
2429 {
2430     struct para_data_s *r = get_parameter( para, key );
2431     char *p, *pn;
2432     unsigned int use;
2433
2434     if( !r )
2435         return 0; /* none (this is an optional parameter)*/
2436
2437     use = 0;
2438     pn = r->u.value;
2439     while ( (p = strsep (&pn, " \t,")) ) {
2440         if ( !*p)
2441             ;
2442         else if ( !ascii_strcasecmp (p, "sign") )
2443             use |= PUBKEY_USAGE_SIG;
2444         else if ( !ascii_strcasecmp (p, "encrypt") )
2445             use |= PUBKEY_USAGE_ENC;
2446         else if ( !ascii_strcasecmp (p, "auth") )
2447             use |= PUBKEY_USAGE_AUTH;
2448         else {
2449             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2450             return -1; /* error */
2451         }
2452     }
2453     r->u.usage = use;
2454     return 1;
2455 }
2456
2457 static int
2458 parse_revocation_key (const char *fname,
2459                       struct para_data_s *para, enum para_name key)
2460 {
2461   struct para_data_s *r = get_parameter( para, key );
2462   struct revocation_key revkey;
2463   char *pn;
2464   int i;
2465
2466   if( !r )
2467     return 0; /* none (this is an optional parameter) */
2468
2469   pn = r->u.value;
2470
2471   revkey.class=0x80;
2472   revkey.algid=atoi(pn);
2473   if(!revkey.algid)
2474     goto fail;
2475
2476   /* Skip to the fpr */
2477   while(*pn && *pn!=':')
2478     pn++;
2479
2480   if(*pn!=':')
2481     goto fail;
2482
2483   pn++;
2484
2485   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2486     {
2487       int c=hextobyte(pn);
2488       if(c==-1)
2489         goto fail;
2490
2491       revkey.fpr[i]=c;
2492     }
2493
2494   /* skip to the tag */
2495   while(*pn && *pn!='s' && *pn!='S')
2496     pn++;
2497
2498   if(ascii_strcasecmp(pn,"sensitive")==0)
2499     revkey.class|=0x40;
2500
2501   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2502
2503   return 0;
2504
2505   fail:
2506   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2507   return -1; /* error */
2508 }
2509
2510
2511 static u32
2512 get_parameter_u32( struct para_data_s *para, enum para_name key )
2513 {
2514   struct para_data_s *r = get_parameter( para, key );
2515
2516   if( !r )
2517     return 0;
2518   if( r->key == pKEYCREATIONDATE )
2519     return r->u.creation;
2520   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2521     return r->u.expire;
2522   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2523     return r->u.usage;
2524
2525   return (unsigned int)strtoul( r->u.value, NULL, 10 );
2526 }
2527
2528 static unsigned int
2529 get_parameter_uint( struct para_data_s *para, enum para_name key )
2530 {
2531     return get_parameter_u32( para, key );
2532 }
2533
2534 static DEK *
2535 get_parameter_dek( struct para_data_s *para, enum para_name key )
2536 {
2537     struct para_data_s *r = get_parameter( para, key );
2538     return r? r->u.dek : NULL;
2539 }
2540
2541 static STRING2KEY *
2542 get_parameter_s2k( struct para_data_s *para, enum para_name key )
2543 {
2544     struct para_data_s *r = get_parameter( para, key );
2545     return r? r->u.s2k : NULL;
2546 }
2547
2548 static struct revocation_key *
2549 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2550 {
2551     struct para_data_s *r = get_parameter( para, key );
2552     return r? &r->u.revkey : NULL;
2553 }
2554
2555 static int
2556 proc_parameter_file( struct para_data_s *para, const char *fname,
2557                      struct output_control_s *outctrl, int card )
2558 {
2559   struct para_data_s *r;
2560   const char *s1, *s2, *s3;
2561   size_t n;
2562   char *p;
2563   int is_default = 0;
2564   int have_user_id = 0;
2565   int err, algo;
2566
2567   /* Check that we have all required parameters. */
2568   r = get_parameter( para, pKEYTYPE );
2569   if(r)
2570     {
2571       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
2572       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
2573         {
2574           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2575           return -1;
2576         }
2577     }
2578   else
2579     {
2580       log_error ("%s: no Key-Type specified\n",fname);
2581       return -1;
2582     }
2583
2584   err = parse_parameter_usage (fname, para, pKEYUSAGE);
2585   if (!err)
2586     {
2587       /* Default to algo capabilities if key-usage is not provided and
2588          no default algorithm has been requested.  */
2589       r = xmalloc_clear(sizeof(*r));
2590       r->key = pKEYUSAGE;
2591       r->u.usage = (is_default
2592                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
2593                     : openpgp_pk_algo_usage(algo));
2594       r->next = para;
2595       para = r;
2596     }
2597   else if (err == -1)
2598     return -1;
2599   else
2600     {
2601       r = get_parameter (para, pKEYUSAGE);
2602       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2603         {
2604           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
2605                      fname, r->lnr, algo);
2606           return -1;
2607         }
2608     }
2609
2610   is_default = 0;
2611   r = get_parameter( para, pSUBKEYTYPE );
2612   if(r)
2613     {
2614       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
2615       if (openpgp_pk_test_algo (algo))
2616         {
2617           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2618           return -1;
2619         }
2620
2621       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2622       if (!err)
2623         {
2624           /* Default to algo capabilities if subkey-usage is not
2625              provided */
2626           r = xmalloc_clear (sizeof(*r));
2627           r->key = pSUBKEYUSAGE;
2628           r->u.usage = (is_default
2629                         ? PUBKEY_USAGE_ENC
2630                         : openpgp_pk_algo_usage (algo));
2631           r->next = para;
2632           para = r;
2633         }
2634       else if (err == -1)
2635         return -1;
2636       else
2637         {
2638           r = get_parameter (para, pSUBKEYUSAGE);
2639           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2640             {
2641               log_error ("%s:%d: specified Subkey-Usage not allowed"
2642                          " for algo %d\n", fname, r->lnr, algo);
2643               return -1;
2644             }
2645         }
2646     }
2647
2648
2649   if( get_parameter_value( para, pUSERID ) )
2650     have_user_id=1;
2651   else
2652     {
2653       /* create the formatted user ID */
2654       s1 = get_parameter_value( para, pNAMEREAL );
2655       s2 = get_parameter_value( para, pNAMECOMMENT );
2656       s3 = get_parameter_value( para, pNAMEEMAIL );
2657       if( s1 || s2 || s3 )
2658         {
2659           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2660           r = xmalloc_clear( sizeof *r + n + 20 );
2661           r->key = pUSERID;
2662           p = r->u.value;
2663           if( s1 )
2664             p = stpcpy(p, s1 );
2665           if( s2 )
2666             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2667           if( s3 )
2668             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2669           r->next = para;
2670           para = r;
2671           have_user_id=1;
2672         }
2673     }
2674
2675   if(!have_user_id)
2676     {
2677       log_error("%s: no User-ID specified\n",fname);
2678       return -1;
2679     }
2680
2681   /* Set preferences, if any. */
2682   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2683
2684   /* Set keyserver, if any. */
2685   s1=get_parameter_value( para, pKEYSERVER );
2686   if(s1)
2687     {
2688       struct keyserver_spec *spec;
2689
2690       spec=parse_keyserver_uri(s1,1,NULL,0);
2691       if(spec)
2692         {
2693           free_keyserver_spec(spec);
2694           opt.def_keyserver_url=s1;
2695         }
2696       else
2697         {
2698           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
2699           return -1;
2700         }
2701     }
2702
2703   /* Set revoker, if any. */
2704   if (parse_revocation_key (fname, para, pREVOKER))
2705     return -1;
2706
2707   /* Make DEK and S2K from the Passphrase. */
2708   if (outctrl->ask_passphrase)
2709     {
2710       /* %ask-passphrase is active - ignore pPASSPRASE and ask.  This
2711          feature is required so that GUIs are able to do a key
2712          creation but have gpg-agent ask for the passphrase.  */
2713       int canceled = 0;
2714       STRING2KEY *s2k;
2715       DEK *dek;
2716
2717       dek = do_ask_passphrase (&s2k, 0, &canceled);
2718       if (dek)
2719         {
2720           r = xmalloc_clear( sizeof *r );
2721           r->key = pPASSPHRASE_DEK;
2722           r->u.dek = dek;
2723           r->next = para;
2724           para = r;
2725           r = xmalloc_clear( sizeof *r );
2726           r->key = pPASSPHRASE_S2K;
2727           r->u.s2k = s2k;
2728           r->next = para;
2729           para = r;
2730         }
2731
2732       if (canceled)
2733         {
2734           log_error ("%s:%d: key generation canceled\n", fname, r->lnr );
2735           return -1;
2736         }
2737     }
2738   else
2739     {
2740       r = get_parameter( para, pPASSPHRASE );
2741       if ( r && *r->u.value )
2742         {
2743           /* We have a plain text passphrase - create a DEK from it.
2744            * It is a little bit ridiculous to keep it in secure memory
2745            * but because we do this always, why not here.  */
2746           STRING2KEY *s2k;
2747           DEK *dek;
2748
2749           s2k = xmalloc_secure ( sizeof *s2k );
2750           s2k->mode = opt.s2k_mode;
2751           s2k->hash_algo = S2K_DIGEST_ALGO;
2752           set_next_passphrase ( r->u.value );
2753           dek = passphrase_to_dek (NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2754                                    NULL, NULL);
2755           set_next_passphrase (NULL );
2756           assert (dek);
2757           memset (r->u.value, 0, strlen(r->u.value));
2758
2759           r = xmalloc_clear (sizeof *r);
2760           r->key = pPASSPHRASE_S2K;
2761           r->u.s2k = s2k;
2762           r->next = para;
2763           para = r;
2764           r = xmalloc_clear (sizeof *r);
2765           r->key = pPASSPHRASE_DEK;
2766           r->u.dek = dek;
2767           r->next = para;
2768           para = r;
2769         }
2770     }
2771
2772   /* Make KEYCREATIONDATE from Creation-Date.  */
2773   r = get_parameter (para, pCREATIONDATE);
2774   if (r && *r->u.value)
2775     {
2776       u32 seconds;
2777
2778       seconds = parse_creation_string (r->u.value);
2779       if (!seconds)
2780         {
2781           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
2782           return -1;
2783         }
2784       r->u.creation = seconds;
2785       r->key = pKEYCREATIONDATE;  /* Change that entry. */
2786     }
2787
2788   /* Make KEYEXPIRE from Expire-Date.  */
2789   r = get_parameter( para, pEXPIREDATE );
2790   if( r && *r->u.value )
2791     {
2792       u32 seconds;
2793
2794       seconds = parse_expire_string( r->u.value );
2795       if( seconds == (u32)-1 )
2796         {
2797           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2798           return -1;
2799         }
2800       r->u.expire = seconds;
2801       r->key = pKEYEXPIRE;  /* change hat entry */
2802       /* also set it for the subkey */
2803       r = xmalloc_clear( sizeof *r + 20 );
2804       r->key = pSUBKEYEXPIRE;
2805       r->u.expire = seconds;
2806       r->next = para;
2807       para = r;
2808     }
2809
2810   if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2811     log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2812     return -1;
2813   }
2814
2815   do_generate_keypair( para, outctrl, card );
2816   return 0;
2817 }
2818
2819
2820 /****************
2821  * Kludge to allow non interactive key generation controlled
2822  * by a parameter file.
2823  * Note, that string parameters are expected to be in UTF-8
2824  */
2825 static void
2826 read_parameter_file( const char *fname )
2827 {
2828     static struct { const char *name;
2829                     enum para_name key;
2830     } keywords[] = {
2831         { "Key-Type",       pKEYTYPE},
2832         { "Key-Length",     pKEYLENGTH },
2833         { "Key-Usage",      pKEYUSAGE },
2834         { "Subkey-Type",    pSUBKEYTYPE },
2835         { "Subkey-Length",  pSUBKEYLENGTH },
2836         { "Subkey-Usage",   pSUBKEYUSAGE },
2837         { "Name-Real",      pNAMEREAL },
2838         { "Name-Email",     pNAMEEMAIL },
2839         { "Name-Comment",   pNAMECOMMENT },
2840         { "Expire-Date",    pEXPIREDATE },
2841         { "Creation-Date",  pCREATIONDATE },
2842         { "Passphrase",     pPASSPHRASE },
2843         { "Preferences",    pPREFERENCES },
2844         { "Revoker",        pREVOKER },
2845         { "Handle",         pHANDLE },
2846         { "Keyserver",      pKEYSERVER },
2847         { NULL, 0 }
2848     };
2849     IOBUF fp;
2850     byte *line;
2851     unsigned int maxlen, nline;
2852     char *p;
2853     int lnr;
2854     const char *err = NULL;
2855     struct para_data_s *para, *r;
2856     int i;
2857     struct output_control_s outctrl;
2858
2859     memset( &outctrl, 0, sizeof( outctrl ) );
2860     outctrl.pub.afx = new_armor_context ();
2861     outctrl.sec.afx = new_armor_context ();
2862
2863     if( !fname || !*fname)
2864       fname = "-";
2865
2866     fp = iobuf_open (fname);
2867     if (fp && is_secured_file (iobuf_get_fd (fp)))
2868       {
2869         iobuf_close (fp);
2870         fp = NULL;
2871         errno = EPERM;
2872       }
2873     if (!fp) {
2874       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2875       return;
2876     }
2877     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2878
2879     lnr = 0;
2880     err = NULL;
2881     para = NULL;
2882     maxlen = 1024;
2883     line = NULL;
2884     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2885         char *keyword, *value;
2886
2887         lnr++;
2888         if( !maxlen ) {
2889             err = "line too long";
2890             break;
2891         }
2892         for( p = line; isspace(*(byte*)p); p++ )
2893             ;
2894         if( !*p || *p == '#' )
2895             continue;
2896         keyword = p;
2897         if( *keyword == '%' ) {
2898             for( ; !isspace(*(byte*)p); p++ )
2899                 ;
2900             if( *p )
2901                 *p++ = 0;
2902             for( ; isspace(*(byte*)p); p++ )
2903                 ;
2904             value = p;
2905             trim_trailing_ws( value, strlen(value) );
2906             if( !ascii_strcasecmp( keyword, "%echo" ) )
2907                 log_info("%s\n", value );
2908             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2909                 outctrl.dryrun = 1;
2910             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
2911                 outctrl.ask_passphrase = 1;
2912             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
2913                 outctrl.ask_passphrase = 0;
2914             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2915                 outctrl.lnr = lnr;
2916                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2917                   print_status_key_not_created
2918                     (get_parameter_value (para, pHANDLE));
2919                 release_parameter_list( para );
2920                 para = NULL;
2921             }
2922             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2923                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2924                     ; /* still the same file - ignore it */
2925                 else {
2926                     xfree( outctrl.pub.newfname );
2927                     outctrl.pub.newfname = xstrdup( value );
2928                     outctrl.use_files = 1;
2929                 }
2930             }
2931             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2932                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2933                     ; /* still the same file - ignore it */
2934                 else {
2935                    xfree( outctrl.sec.newfname );
2936                    outctrl.sec.newfname = xstrdup( value );
2937                    outctrl.use_files = 1;
2938                 }
2939             }
2940             else
2941                 log_info("skipping control `%s' (%s)\n", keyword, value );
2942
2943
2944             continue;
2945         }
2946
2947
2948         if( !(p = strchr( p, ':' )) || p == keyword ) {
2949             err = "missing colon";
2950             break;
2951         }
2952         if( *p )
2953             *p++ = 0;
2954         for( ; isspace(*(byte*)p); p++ )
2955             ;
2956         if( !*p ) {
2957             err = "missing argument";
2958             break;
2959         }
2960         value = p;
2961         trim_trailing_ws( value, strlen(value) );
2962
2963         for(i=0; keywords[i].name; i++ ) {
2964             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2965                 break;
2966         }
2967         if( !keywords[i].name ) {
2968             err = "unknown keyword";
2969             break;
2970         }
2971         if( keywords[i].key != pKEYTYPE && !para ) {
2972             err = "parameter block does not start with \"Key-Type\"";
2973             break;
2974         }
2975
2976         if( keywords[i].key == pKEYTYPE && para ) {
2977             outctrl.lnr = lnr;
2978             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2979               print_status_key_not_created
2980                 (get_parameter_value (para, pHANDLE));
2981             release_parameter_list( para );
2982             para = NULL;
2983         }
2984         else {
2985             for( r = para; r; r = r->next ) {
2986                 if( r->key == keywords[i].key )
2987                     break;
2988             }
2989             if( r ) {
2990                 err = "duplicate keyword";
2991                 break;
2992             }
2993         }
2994         r = xmalloc_clear( sizeof *r + strlen( value ) );
2995         r->lnr = lnr;
2996         r->key = keywords[i].key;
2997         strcpy( r->u.value, value );
2998         r->next = para;
2999         para = r;
3000     }
3001     if( err )
3002         log_error("%s:%d: %s\n", fname, lnr, err );
3003     else if( iobuf_error (fp) ) {
3004         log_error("%s:%d: read error\n", fname, lnr);
3005     }
3006     else if( para ) {
3007         outctrl.lnr = lnr;
3008         if (proc_parameter_file( para, fname, &outctrl, 0 ))
3009           print_status_key_not_created (get_parameter_value (para, pHANDLE));
3010     }
3011
3012     if( outctrl.use_files ) { /* close open streams */
3013         iobuf_close( outctrl.pub.stream );
3014         iobuf_close( outctrl.sec.stream );
3015
3016         /* Must invalidate that ugly cache to actually close it.  */
3017         if (outctrl.pub.fname)
3018           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
3019         if (outctrl.sec.fname)
3020           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
3021
3022         xfree( outctrl.pub.fname );
3023         xfree( outctrl.pub.newfname );
3024         xfree( outctrl.sec.fname );
3025         xfree( outctrl.sec.newfname );
3026     }
3027
3028     release_parameter_list( para );
3029     iobuf_close (fp);
3030     release_armor_context (outctrl.pub.afx);
3031     release_armor_context (outctrl.sec.afx);
3032 }
3033
3034
3035 /*
3036  * Generate a keypair (fname is only used in batch mode) If
3037  * CARD_SERIALNO is not NULL the function will create the keys on an
3038  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
3039  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
3040  * generate in software, imported to the card and a backup file
3041  * written to directory given by this argument .
3042  */
3043 void
3044 generate_keypair (const char *fname, const char *card_serialno,
3045                   const char *backup_encryption_dir)
3046 {
3047   unsigned int nbits;
3048   char *uid = NULL;
3049   DEK *dek;
3050   STRING2KEY *s2k;
3051   int algo;
3052   unsigned int use;
3053   int both = 0;
3054   u32 expire;
3055   struct para_data_s *para = NULL;
3056   struct para_data_s *r;
3057   struct output_control_s outctrl;
3058   int canceled;
3059
3060   memset( &outctrl, 0, sizeof( outctrl ) );
3061
3062   if (opt.batch && card_serialno)
3063     {
3064       /* We don't yet support unattended key generation. */
3065       log_error (_("can't do this in batch mode\n"));
3066       return;
3067     }
3068
3069   if (opt.batch)
3070     {
3071       read_parameter_file( fname );
3072       return;
3073     }
3074
3075   if (card_serialno)
3076     {
3077 #ifdef ENABLE_CARD_SUPPORT
3078       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
3079       r->key = pSERIALNO;
3080       strcpy( r->u.value, card_serialno);
3081       r->next = para;
3082       para = r;
3083
3084       algo = PUBKEY_ALGO_RSA;
3085
3086       r = xcalloc (1, sizeof *r + 20 );
3087       r->key = pKEYTYPE;
3088       sprintf( r->u.value, "%d", algo );
3089       r->next = para;
3090       para = r;
3091       r = xcalloc (1, sizeof *r + 20 );
3092       r->key = pKEYUSAGE;
3093       strcpy (r->u.value, "sign");
3094       r->next = para;
3095       para = r;
3096
3097       r = xcalloc (1, sizeof *r + 20 );
3098       r->key = pSUBKEYTYPE;
3099       sprintf( r->u.value, "%d", algo );
3100       r->next = para;
3101       para = r;
3102       r = xcalloc (1, sizeof *r + 20 );
3103       r->key = pSUBKEYUSAGE;
3104       strcpy (r->u.value, "encrypt");
3105       r->next = para;
3106       para = r;
3107
3108       r = xcalloc (1, sizeof *r + 20 );
3109       r->key = pAUTHKEYTYPE;
3110       sprintf( r->u.value, "%d", algo );
3111       r->next = para;
3112       para = r;
3113
3114       if (backup_encryption_dir)
3115         {
3116           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
3117           r->key = pBACKUPENCDIR;
3118           strcpy (r->u.value, backup_encryption_dir);
3119           r->next = para;
3120           para = r;
3121         }
3122 #endif /*ENABLE_CARD_SUPPORT*/
3123     }
3124   else
3125     {
3126       int subkey_algo;
3127
3128       algo = ask_algo (0, &subkey_algo, &use);
3129       if (subkey_algo)
3130         {
3131           /* Create primary and subkey at once.  */
3132           both = 1;
3133           r = xmalloc_clear( sizeof *r + 20 );
3134           r->key = pKEYTYPE;
3135           sprintf( r->u.value, "%d", algo );
3136           r->next = para;
3137           para = r;
3138           nbits = ask_keysize (algo, 0);
3139           r = xmalloc_clear( sizeof *r + 20 );
3140           r->key = pKEYLENGTH;
3141           sprintf( r->u.value, "%u", nbits);
3142           r->next = para;
3143           para = r;
3144           r = xmalloc_clear( sizeof *r + 20 );
3145           r->key = pKEYUSAGE;
3146           strcpy( r->u.value, "sign" );
3147           r->next = para;
3148           para = r;
3149
3150           r = xmalloc_clear( sizeof *r + 20 );
3151           r->key = pSUBKEYTYPE;
3152           sprintf( r->u.value, "%d", subkey_algo);
3153           r->next = para;
3154           para = r;
3155           r = xmalloc_clear( sizeof *r + 20 );
3156           r->key = pSUBKEYUSAGE;
3157           strcpy( r->u.value, "encrypt" );
3158           r->next = para;
3159           para = r;
3160         }
3161       else
3162         {
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
3169           if (use)
3170             {
3171               r = xmalloc_clear( sizeof *r + 25 );
3172               r->key = pKEYUSAGE;
3173               sprintf( r->u.value, "%s%s%s",
3174                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
3175                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
3176                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
3177               r->next = para;
3178               para = r;
3179             }
3180           nbits = 0;
3181         }
3182
3183       nbits = ask_keysize (both? subkey_algo : algo, nbits);
3184       r = xmalloc_clear( sizeof *r + 20 );
3185       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
3186       sprintf( r->u.value, "%u", nbits);
3187       r->next = para;
3188       para = r;
3189     }
3190
3191   expire = ask_expire_interval(0,NULL);
3192   r = xmalloc_clear( sizeof *r + 20 );
3193   r->key = pKEYEXPIRE;
3194   r->u.expire = expire;
3195   r->next = para;
3196   para = r;
3197   r = xmalloc_clear( sizeof *r + 20 );
3198   r->key = pSUBKEYEXPIRE;
3199   r->u.expire = expire;
3200   r->next = para;
3201   para = r;
3202
3203   uid = ask_user_id (0, NULL);
3204   if( !uid )
3205     {
3206       log_error(_("Key generation canceled.\n"));
3207       release_parameter_list( para );
3208       return;
3209     }
3210   r = xmalloc_clear( sizeof *r + strlen(uid) );
3211   r->key = pUSERID;
3212   strcpy( r->u.value, uid );
3213   r->next = para;
3214   para = r;
3215
3216   canceled = 0;
3217   dek = card_serialno? NULL : do_ask_passphrase (&s2k, 0, &canceled);
3218   if( dek )
3219     {
3220       r = xmalloc_clear( sizeof *r );
3221       r->key = pPASSPHRASE_DEK;
3222       r->u.dek = dek;
3223       r->next = para;
3224       para = r;
3225       r = xmalloc_clear( sizeof *r );
3226       r->key = pPASSPHRASE_S2K;
3227       r->u.s2k = s2k;
3228       r->next = para;
3229       para = r;
3230     }
3231
3232   if (canceled)
3233     log_error (_("Key generation canceled.\n"));
3234   else
3235     proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
3236   release_parameter_list( para );
3237 }
3238
3239
3240 #ifdef ENABLE_CARD_SUPPORT
3241 /* Generate a raw key and return it as a secret key packet.  The
3242    function will ask for the passphrase and return a protected as well
3243    as an unprotected copy of a new secret key packet.  0 is returned
3244    on success and the caller must then free the returned values.  */
3245 static int
3246 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
3247                   PKT_secret_key **r_sk_unprotected,
3248                   PKT_secret_key **r_sk_protected)
3249 {
3250   int rc;
3251   DEK *dek = NULL;
3252   STRING2KEY *s2k = NULL;
3253   PKT_secret_key *sk = NULL;
3254   int i;
3255   size_t nskey, npkey;
3256   gcry_sexp_t s_parms, s_key;
3257   int canceled;
3258
3259   npkey = pubkey_get_npkey (algo);
3260   nskey = pubkey_get_nskey (algo);
3261   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
3262
3263   if (nbits < 512)
3264     {
3265       nbits = 512;
3266       log_info (_("keysize invalid; using %u bits\n"), nbits );
3267     }
3268
3269   if ((nbits % 32))
3270     {
3271       nbits = ((nbits + 31) / 32) * 32;
3272       log_info(_("keysize rounded up to %u bits\n"), nbits );
3273     }
3274
3275   dek = do_ask_passphrase (&s2k, 1, &canceled);
3276   if (canceled)
3277     {
3278       rc = gpg_error (GPG_ERR_CANCELED);
3279       goto leave;
3280     }
3281
3282   sk = xmalloc_clear (sizeof *sk);
3283   sk->timestamp = created_at;
3284   sk->version = 4;
3285   sk->pubkey_algo = algo;
3286
3287   if ( !is_RSA (algo) )
3288     {
3289       log_error ("only RSA is supported for offline generated keys\n");
3290       rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3291       goto leave;
3292     }
3293   rc = gcry_sexp_build (&s_parms, NULL,
3294                         "(genkey(rsa(nbits %d)))",
3295                         (int)nbits);
3296   if (rc)
3297     log_bug ("gcry_sexp_build failed: %s\n", gpg_strerror (rc));
3298   rc = gcry_pk_genkey (&s_key, s_parms);
3299   gcry_sexp_release (s_parms);
3300   if (rc)
3301     {
3302       log_error ("gcry_pk_genkey failed: %s\n", gpg_strerror (rc) );
3303       goto leave;
3304     }
3305   rc = key_from_sexp (sk->skey, s_key, "private-key", "nedpqu");
3306   gcry_sexp_release (s_key);
3307   if (rc)
3308     {
3309       log_error ("key_from_sexp failed: %s\n", gpg_strerror (rc) );
3310       goto leave;
3311     }
3312
3313   for (i=npkey; i < nskey; i++)
3314     sk->csum += checksum_mpi (sk->skey[i]);
3315
3316   if (r_sk_unprotected)
3317     *r_sk_unprotected = copy_secret_key (NULL, sk);
3318
3319   rc = genhelp_protect (dek, s2k, sk);
3320   if (rc)
3321     goto leave;
3322
3323   if (r_sk_protected)
3324     {
3325       *r_sk_protected = sk;
3326       sk = NULL;
3327     }
3328
3329  leave:
3330   if (sk)
3331     free_secret_key (sk);
3332   xfree (dek);
3333   xfree (s2k);
3334   return rc;
3335 }
3336 #endif /* ENABLE_CARD_SUPPORT */
3337
3338 /* Create and delete a dummy packet to start off a list of kbnodes. */
3339 static void
3340 start_tree(KBNODE *tree)
3341 {
3342   PACKET *pkt;
3343
3344   pkt=xmalloc_clear(sizeof(*pkt));
3345   pkt->pkttype=PKT_NONE;
3346   *tree=new_kbnode(pkt);
3347   delete_kbnode(*tree);
3348 }
3349
3350
3351 static void
3352 do_generate_keypair (struct para_data_s *para,
3353                      struct output_control_s *outctrl, int card)
3354 {
3355   KBNODE pub_root = NULL;
3356   KBNODE sec_root = NULL;
3357   PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3358   const char *s;
3359   struct revocation_key *revkey;
3360   int rc;
3361   int did_sub = 0;
3362   u32 timestamp;
3363
3364   if( outctrl->dryrun )
3365     {
3366       log_info("dry-run mode - key generation skipped\n");
3367       return;
3368     }
3369
3370   if ( outctrl->use_files )
3371     {
3372       if ( outctrl->pub.newfname )
3373         {
3374           iobuf_close(outctrl->pub.stream);
3375           outctrl->pub.stream = NULL;
3376           if (outctrl->pub.fname)
3377             iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
3378           xfree( outctrl->pub.fname );
3379           outctrl->pub.fname =  outctrl->pub.newfname;
3380           outctrl->pub.newfname = NULL;
3381
3382           if (is_secured_filename (outctrl->pub.fname) )
3383             {
3384               outctrl->pub.stream = NULL;
3385               errno = EPERM;
3386             }
3387           else
3388             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
3389           if (!outctrl->pub.stream)
3390             {
3391               log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
3392                         strerror(errno) );
3393               return;
3394             }
3395           if (opt.armor)
3396             {
3397               outctrl->pub.afx->what = 1;
3398               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
3399             }
3400         }
3401       if (outctrl->sec.newfname)
3402         {
3403           mode_t oldmask;
3404
3405           iobuf_close(outctrl->sec.stream);
3406           outctrl->sec.stream = NULL;
3407           if (outctrl->sec.fname)
3408             iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
3409           xfree( outctrl->sec.fname );
3410           outctrl->sec.fname =  outctrl->sec.newfname;
3411           outctrl->sec.newfname = NULL;
3412
3413           oldmask = umask (077);
3414           if (is_secured_filename (outctrl->sec.fname) )
3415             {
3416               outctrl->sec.stream = NULL;
3417               errno = EPERM;
3418             }
3419           else
3420             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
3421           umask (oldmask);
3422           if (!outctrl->sec.stream)
3423             {
3424               log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
3425                         strerror(errno) );
3426               return;
3427             }
3428           if (opt.armor)
3429             {
3430               outctrl->sec.afx->what = 5;
3431               push_armor_filter (outctrl->sec.afx, outctrl->sec.stream);
3432             }
3433         }
3434       assert( outctrl->pub.stream );
3435       assert( outctrl->sec.stream );
3436       if (opt.verbose)
3437         {
3438           log_info (_("writing public key to `%s'\n"), outctrl->pub.fname );
3439           if (card)
3440             log_info (_("writing secret key stub to `%s'\n"),
3441                       outctrl->sec.fname);
3442           else
3443             log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
3444         }
3445     }
3446
3447
3448   /* We create the packets as a tree of kbnodes.  Because the
3449      structure we create is known in advance we simply generate a
3450      linked list.  The first packet is a dummy packet which we flag as
3451      deleted.  The very first packet must always be a KEY packet.  */
3452
3453   start_tree (&pub_root);
3454   start_tree (&sec_root);
3455
3456   timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
3457   if (!timestamp)
3458     timestamp = make_timestamp ();
3459
3460   /* Note that, depending on the backend (i.e. the used scdaemon
3461      version), the card key generation may update TIMESTAMP for each
3462      key.  Thus we need to pass TIMESTAMP to all signing function to
3463      make sure that the binding signature is done using the timestamp
3464      of the corresponding (sub)key and not that of the primary key.
3465      An alternative implementation could tell the signing function the
3466      node of the subkey but that is more work than just to pass the
3467      current timestamp.  */
3468
3469   if (!card)
3470     {
3471       rc = do_create (get_parameter_algo( para, pKEYTYPE, NULL ),
3472                       get_parameter_uint( para, pKEYLENGTH ),
3473                       pub_root, sec_root,
3474                       get_parameter_dek( para, pPASSPHRASE_DEK ),
3475                       get_parameter_s2k( para, pPASSPHRASE_S2K ),
3476                       &pri_sk,
3477                       timestamp,
3478                       get_parameter_u32( para, pKEYEXPIRE ), 0 );
3479     }
3480   else
3481     {
3482       rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root, NULL,
3483                          &timestamp,
3484                          get_parameter_u32 (para, pKEYEXPIRE), para);
3485       if (!rc)
3486         {
3487           pri_sk = sec_root->next->pkt->pkt.secret_key;
3488           assert (pri_sk);
3489         }
3490     }
3491
3492   if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
3493     {
3494       rc = write_direct_sig (pub_root, pub_root, pri_sk, revkey, timestamp);
3495       if (!rc)
3496         rc = write_direct_sig (sec_root, pub_root, pri_sk, revkey, timestamp);
3497     }
3498
3499   if( !rc && (s=get_parameter_value(para, pUSERID)) )
3500     {
3501       write_uid (pub_root, s );
3502       write_uid (sec_root, s );
3503
3504       rc = write_selfsigs (sec_root, pub_root, pri_sk,
3505                            get_parameter_uint (para, pKEYUSAGE), timestamp);
3506     }
3507
3508   /* Write the auth key to the card before the encryption key.  This
3509      is a partial workaround for a PGP bug (as of this writing, all
3510      versions including 8.1), that causes it to try and encrypt to
3511      the most recent subkey regardless of whether that subkey is
3512      actually an encryption type.  In this case, the auth key is an
3513      RSA key so it succeeds. */
3514
3515   if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
3516     {
3517       rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root, NULL,
3518                          &timestamp,
3519                          get_parameter_u32 (para, pKEYEXPIRE), para);
3520
3521       if (!rc)
3522         rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk,
3523                                PUBKEY_USAGE_AUTH, timestamp);
3524       if (!rc)
3525         rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk,
3526                                PUBKEY_USAGE_AUTH, timestamp);
3527     }
3528
3529   if( !rc && get_parameter( para, pSUBKEYTYPE ) )
3530     {
3531       if (!card)
3532         {
3533           rc = do_create( get_parameter_algo( para, pSUBKEYTYPE, NULL ),
3534                           get_parameter_uint( para, pSUBKEYLENGTH ),
3535                           pub_root, sec_root,
3536                           get_parameter_dek( para, pPASSPHRASE_DEK ),
3537                           get_parameter_s2k( para, pPASSPHRASE_S2K ),
3538                           &sub_sk,
3539                           timestamp,
3540                           get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
3541         }
3542       else
3543         {
3544           if ((s = get_parameter_value (para, pBACKUPENCDIR)))
3545             {
3546               /* A backup of the encryption key has been requested.
3547                  Generate the key in software and import it then to
3548                  the card.  Write a backup file. */
3549               rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
3550                                              pub_root, sec_root,
3551                                              timestamp,
3552                                              get_parameter_u32 (para,
3553                                                                 pKEYEXPIRE),
3554                                              para, s);
3555             }
3556           else
3557             {
3558               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
3559                                  NULL,
3560                                  &timestamp,
3561                                  get_parameter_u32 (para, pKEYEXPIRE), para);
3562             }
3563         }
3564
3565       if( !rc )
3566         rc = write_keybinding(pub_root, pub_root, pri_sk, sub_sk,
3567                               get_parameter_uint (para, pSUBKEYUSAGE),
3568                               timestamp);
3569       if( !rc )
3570         rc = write_keybinding(sec_root, pub_root, pri_sk, sub_sk,
3571                               get_parameter_uint (para, pSUBKEYUSAGE),
3572                               timestamp);
3573       did_sub = 1;
3574     }
3575
3576   if (!rc && outctrl->use_files)  /* Direct write to specified files.  */
3577     {
3578       rc = write_keyblock( outctrl->pub.stream, pub_root );
3579       if (rc)
3580         log_error ("can't write public key: %s\n", g10_errstr(rc) );
3581       if (!rc)
3582         {
3583           rc = write_keyblock( outctrl->sec.stream, sec_root );
3584           if(rc)
3585             log_error ("can't write secret key: %s\n", g10_errstr(rc) );
3586         }
3587     }
3588   else if (!rc) /* Write to the standard keyrings.  */
3589     {
3590       KEYDB_HANDLE pub_hd = keydb_new (0);
3591       KEYDB_HANDLE sec_hd = keydb_new (1);
3592
3593       rc = keydb_locate_writable (pub_hd, NULL);
3594       if (rc)
3595         log_error (_("no writable public keyring found: %s\n"),
3596                    g10_errstr (rc));
3597
3598       if (!rc)
3599         {
3600           rc = keydb_locate_writable (sec_hd, NULL);
3601           if (rc)
3602             log_error (_("no writable secret keyring found: %s\n"),
3603                        g10_errstr (rc));
3604         }
3605
3606       if (!rc && opt.verbose)
3607         {
3608           log_info (_("writing public key to `%s'\n"),
3609                     keydb_get_resource_name (pub_hd));
3610           if (card)
3611             log_info (_("writing secret key stub to `%s'\n"),
3612                       keydb_get_resource_name (sec_hd));
3613           else
3614             log_info (_("writing secret key to `%s'\n"),
3615                       keydb_get_resource_name (sec_hd));
3616         }
3617
3618       if (!rc)
3619         {
3620           rc = keydb_insert_keyblock (pub_hd, pub_root);
3621           if (rc)
3622             log_error (_("error writing public keyring `%s': %s\n"),
3623                        keydb_get_resource_name (pub_hd), g10_errstr(rc));
3624         }
3625
3626       if (!rc)
3627         {
3628           rc = keydb_insert_keyblock (sec_hd, sec_root);
3629           if (rc)
3630             log_error (_("error writing secret keyring `%s': %s\n"),
3631                        keydb_get_resource_name (pub_hd), g10_errstr(rc));
3632         }
3633
3634       keydb_release (pub_hd);
3635       keydb_release (sec_hd);
3636
3637       if (!rc)
3638         {
3639           int no_enc_rsa;
3640           PKT_public_key *pk;
3641
3642           no_enc_rsa = ((get_parameter_algo (para, pKEYTYPE, NULL)
3643                          == PUBKEY_ALGO_RSA)
3644                         && get_parameter_uint (para, pKEYUSAGE)
3645                         && !((get_parameter_uint (para, pKEYUSAGE)
3646                               & PUBKEY_USAGE_ENC)) );
3647
3648           pk = find_kbnode (pub_root, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3649
3650           keyid_from_pk(pk,pk->main_keyid);
3651           register_trusted_keyid(pk->main_keyid);
3652