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