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