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