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