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