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