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