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