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