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