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