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