90209083fb02ad86772c34bc2cb50ad8058da3ab
[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;
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       answer = cpr_get ("keygen.algo", _("Your selection? "));
1516       cpr_kill_prompt ();
1517       algo = *answer? atoi(answer): 1;
1518       xfree (answer);
1519       if ( algo == 1 && !addmode )
1520         {
1521           algo = PUBKEY_ALGO_RSA;
1522           *r_subkey_algo = PUBKEY_ALGO_RSA;
1523           break;
1524         }
1525       else if (algo == 2 && !addmode)
1526         {
1527           algo = PUBKEY_ALGO_DSA;
1528           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
1529           break;
1530         }
1531       else if (algo == 3)
1532         {
1533           algo = PUBKEY_ALGO_DSA;
1534           *r_usage = PUBKEY_USAGE_SIG;
1535           break;
1536         }
1537       else if (algo == 4)
1538         {
1539           algo = PUBKEY_ALGO_RSA;
1540           *r_usage = PUBKEY_USAGE_SIG;
1541           break;
1542         }
1543       else if (algo == 5 && addmode)
1544         {
1545           algo = PUBKEY_ALGO_ELGAMAL_E;
1546           *r_usage = PUBKEY_USAGE_ENC;
1547           break;
1548         }
1549       else if (algo == 6 && addmode)
1550         {
1551           algo = PUBKEY_ALGO_RSA;
1552           *r_usage = PUBKEY_USAGE_ENC;
1553           break;
1554         }
1555       else if (algo == 7 && opt.expert)
1556         {
1557           algo = PUBKEY_ALGO_DSA;
1558           *r_usage = ask_key_flags (algo, addmode);
1559           break;
1560         }
1561       else if (algo == 8 && 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   return algo;
1572 }
1573
1574
1575 /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
1576    is not 0, the function asks for the size of the encryption
1577    subkey.  */
1578 static unsigned int
1579 ask_keysize (int algo, unsigned int primary_keysize)
1580 {
1581   unsigned nbits, min, def=2048, max=4096;
1582   int for_subkey = !!primary_keysize;
1583   int autocomp = 0;
1584
1585   if(opt.expert)
1586     min=512;
1587   else
1588     min=1024;
1589
1590   if (primary_keysize && !opt.expert)
1591     {
1592       /* Deduce the subkey size from the primary key size.  */
1593       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
1594         nbits = 3072; /* For performance reasons we don't support more
1595                          than 3072 bit DSA.  However we won't see this
1596                          case anyway because DSA can't be used as an
1597                          encryption subkey ;-). */
1598       else
1599         nbits = primary_keysize;
1600       autocomp = 1;
1601       goto leave;
1602     }
1603
1604   switch(algo)
1605     {
1606     case PUBKEY_ALGO_DSA:
1607       def=2048;
1608       max=3072;
1609       break;
1610
1611     case PUBKEY_ALGO_RSA:
1612       min=1024;
1613       break;
1614     }
1615
1616   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
1617              pubkey_algo_to_string(algo),min,max);
1618
1619   for(;;)
1620     {
1621       char *prompt,*answer;
1622
1623       if (for_subkey)
1624         prompt = xasprintf (_("What keysize do you want "
1625                               "for the subkey? (%u) "), def);
1626       else
1627         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
1628
1629       answer = cpr_get("keygen.size",prompt);
1630       cpr_kill_prompt();
1631       nbits = *answer? atoi(answer): def;
1632       xfree(prompt);
1633       xfree(answer);
1634
1635       if(nbits<min || nbits>max)
1636         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
1637                    pubkey_algo_to_string(algo),min,max);
1638       else
1639         break;
1640     }
1641
1642   tty_printf(_("Requested keysize is %u bits\n"), nbits );
1643
1644  leave:
1645   if( algo == PUBKEY_ALGO_DSA && (nbits % 64) )
1646     {
1647       nbits = ((nbits + 63) / 64) * 64;
1648       if (!autocomp)
1649         tty_printf (_("rounded up to %u bits\n"), nbits);
1650     }
1651   else if( (nbits % 32) )
1652     {
1653       nbits = ((nbits + 31) / 32) * 32;
1654       if (!autocomp)
1655         tty_printf (_("rounded up to %u bits\n"), nbits);
1656     }
1657
1658   return nbits;
1659 }
1660
1661
1662 /****************
1663  * Parse an expire string and return its value in seconds.
1664  * Returns (u32)-1 on error.
1665  * This isn't perfect since scan_isodatestr returns unix time, and
1666  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
1667  * Because of this, we only permit setting expirations up to 2106, but
1668  * OpenPGP could theoretically allow up to 2242.  I think we'll all
1669  * just cope for the next few years until we get a 64-bit time_t or
1670  * similar.
1671  */
1672 u32
1673 parse_expire_string (u32 timestamp, const char *string)
1674 {
1675   int mult;
1676   u32 seconds;
1677   u32 abs_date = 0;
1678
1679   if ( !*string )
1680     seconds = 0;
1681   else if ( !strncmp (string, "seconds=", 8) )
1682     seconds = atoi (string+8);
1683   else if( (abs_date = scan_isodatestr(string)) && abs_date > timestamp )
1684     seconds = abs_date - timestamp;
1685   else if( (mult=check_valid_days(string)) )
1686     seconds = atoi(string) * 86400L * mult;
1687   else
1688     seconds=(u32)-1;
1689
1690   return seconds;
1691 }
1692
1693 /* Parse an Creation-Date string which is either "1986-04-26" or
1694    "19860426T042640".  Returns 0 on error. */
1695 static u32
1696 parse_creation_string (const char *string)
1697 {
1698   u32 seconds;
1699
1700   if (!*string)
1701     seconds = 0;
1702   else if ( !strncmp (string, "seconds=", 8) )
1703     seconds = atoi (string+8);
1704   else if ( !(seconds = scan_isodatestr (string)))
1705     seconds = isotime2seconds (string);
1706   return seconds;
1707 }
1708
1709
1710 /* object == 0 for a key, and 1 for a sig */
1711 u32
1712 ask_expire_interval(u32 timestamp,int object,const char *def_expire)
1713 {
1714     u32 interval;
1715     char *answer;
1716
1717     switch(object)
1718       {
1719       case 0:
1720         if(def_expire)
1721           BUG();
1722         tty_printf(_("Please specify how long the key should be valid.\n"
1723                      "         0 = key does not expire\n"
1724                      "      <n>  = key expires in n days\n"
1725                      "      <n>w = key expires in n weeks\n"
1726                      "      <n>m = key expires in n months\n"
1727                      "      <n>y = key expires in n years\n"));
1728         break;
1729
1730       case 1:
1731         if(!def_expire)
1732           BUG();
1733         tty_printf(_("Please specify how long the signature should be valid.\n"
1734                      "         0 = signature does not expire\n"
1735                      "      <n>  = signature expires in n days\n"
1736                      "      <n>w = signature expires in n weeks\n"
1737                      "      <n>m = signature expires in n months\n"
1738                      "      <n>y = signature expires in n years\n"));
1739         break;
1740
1741       default:
1742         BUG();
1743       }
1744
1745     /* Note: The elgamal subkey for DSA has no expiration date because
1746      * it must be signed with the DSA key and this one has the expiration
1747      * date */
1748
1749     answer = NULL;
1750     for(;;)
1751       {
1752         xfree(answer);
1753         if(object==0)
1754           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1755         else
1756           {
1757             char *prompt;
1758
1759 #define PROMPTSTRING _("Signature is valid for? (%s) ")
1760             /* This will actually end up larger than necessary because
1761                of the 2 bytes for '%s' */
1762             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
1763             sprintf(prompt,PROMPTSTRING,def_expire);
1764 #undef PROMPTSTRING
1765
1766             answer = cpr_get("siggen.valid",prompt);
1767             xfree(prompt);
1768
1769             if(*answer=='\0')
1770               answer=xstrdup(def_expire);
1771           }
1772         cpr_kill_prompt();
1773         trim_spaces(answer);
1774         interval = parse_expire_string (timestamp, answer);
1775         if( interval == (u32)-1 )
1776           {
1777             tty_printf(_("invalid value\n"));
1778             continue;
1779           }
1780
1781         if( !interval )
1782           {
1783             tty_printf((object==0)
1784                        ? _("Key does not expire at all\n")
1785                        : _("Signature does not expire at all\n"));
1786           }
1787         else
1788           {
1789             tty_printf(object==0
1790                        ? _("Key expires at %s\n")
1791                        : _("Signature expires at %s\n"),
1792                        asctimestamp((ulong)(timestamp + interval) ) );
1793 #if SIZEOF_TIME_T <= 4 && !defined(HAVE_UNSIGNED_TIME_T)
1794             if ((time_t)((ulong)(timestamp+interval)) < 0 )
1795               tty_printf (_("Your system can't display dates beyond 2038.\n"
1796                             "However, it will be correctly handled up to"
1797                             " 2106.\n"));
1798             else
1799 #endif /*SIZEOF_TIME_T*/
1800               if ( (time_t)((unsigned long)(timestamp+interval)) < timestamp )
1801                 {
1802                   tty_printf (_("invalid value\n"));
1803                   continue;
1804                 }
1805           }
1806
1807         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1808                                                    _("Is this correct? (y/N) ")) )
1809           break;
1810       }
1811
1812     xfree(answer);
1813     return interval;
1814 }
1815
1816 static char *
1817 ask_user_id( int mode )
1818 {
1819     char *answer;
1820     char *aname, *acomment, *amail, *uid;
1821
1822     if( !mode )
1823         tty_printf( _("\n"
1824 "You need a user ID to identify your key; "
1825                                         "the software constructs the user ID\n"
1826 "from the Real Name, Comment and Email Address in this form:\n"
1827 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
1828     uid = aname = acomment = amail = NULL;
1829     for(;;) {
1830         char *p;
1831         int fail=0;
1832
1833         if( !aname ) {
1834             for(;;) {
1835                 xfree(aname);
1836                 aname = cpr_get("keygen.name",_("Real name: "));
1837                 trim_spaces(aname);
1838                 cpr_kill_prompt();
1839
1840                 if( opt.allow_freeform_uid )
1841                     break;
1842
1843                 if( strpbrk( aname, "<>" ) )
1844                     tty_printf(_("Invalid character in name\n"));
1845                 else if( digitp(aname) )
1846                     tty_printf(_("Name may not start with a digit\n"));
1847                 else if( strlen(aname) < 5 )
1848                     tty_printf(_("Name must be at least 5 characters long\n"));
1849                 else
1850                     break;
1851             }
1852         }
1853         if( !amail ) {
1854             for(;;) {
1855                 xfree(amail);
1856                 amail = cpr_get("keygen.email",_("Email address: "));
1857                 trim_spaces(amail);
1858                 cpr_kill_prompt();
1859                 if( !*amail || opt.allow_freeform_uid )
1860                     break;   /* no email address is okay */
1861                 else if ( !is_valid_mailbox (amail) )
1862                     tty_printf(_("Not a valid email address\n"));
1863                 else
1864                     break;
1865             }
1866         }
1867         if( !acomment ) {
1868             for(;;) {
1869                 xfree(acomment);
1870                 acomment = cpr_get("keygen.comment",_("Comment: "));
1871                 trim_spaces(acomment);
1872                 cpr_kill_prompt();
1873                 if( !*acomment )
1874                     break;   /* no comment is okay */
1875                 else if( strpbrk( acomment, "()" ) )
1876                     tty_printf(_("Invalid character in comment\n"));
1877                 else
1878                     break;
1879             }
1880         }
1881
1882
1883         xfree(uid);
1884         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1885         p = stpcpy(p, aname );
1886         if( *acomment )
1887             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1888         if( *amail )
1889             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1890
1891         /* append a warning if we do not have dev/random
1892          * or it is switched into  quick testmode */
1893         if( quick_random_gen(-1) )
1894             strcpy(p, " (INSECURE!)" );
1895
1896         /* print a note in case that UTF8 mapping has to be done */
1897         for(p=uid; *p; p++ ) {
1898             if( *p & 0x80 ) {
1899                 tty_printf(_("You are using the `%s' character set.\n"),
1900                            get_native_charset() );
1901                 break;
1902             }
1903         }
1904
1905         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1906         /* fixme: add a warning if this user-id already exists */
1907         if( !*amail && !opt.allow_freeform_uid
1908             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1909             fail = 1;
1910             tty_printf(_("Please don't put the email address "
1911                           "into the real name or the comment\n") );
1912         }
1913
1914         for(;;) {
1915             /* TRANSLATORS: These are the allowed answers in
1916                lower and uppercase.  Below you will find the matching
1917                string which should be translated accordingly and the
1918                letter changed to match the one in the answer string.
1919
1920                  n = Change name
1921                  c = Change comment
1922                  e = Change email
1923                  o = Okay (ready, continue)
1924                  q = Quit
1925              */
1926             const char *ansstr = _("NnCcEeOoQq");
1927
1928             if( strlen(ansstr) != 10 )
1929                 BUG();
1930             if( cpr_enabled() ) {
1931                 answer = xstrdup (ansstr + (fail?8:6));
1932                 answer[1] = 0;
1933             }
1934             else {
1935                 answer = cpr_get("keygen.userid.cmd", fail?
1936                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1937                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1938                 cpr_kill_prompt();
1939             }
1940             if( strlen(answer) > 1 )
1941                 ;
1942             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1943                 xfree(aname); aname = NULL;
1944                 break;
1945             }
1946             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1947                 xfree(acomment); acomment = NULL;
1948                 break;
1949             }
1950             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1951                 xfree(amail); amail = NULL;
1952                 break;
1953             }
1954             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1955                 if( fail ) {
1956                     tty_printf(_("Please correct the error first\n"));
1957                 }
1958                 else {
1959                     xfree(aname); aname = NULL;
1960                     xfree(acomment); acomment = NULL;
1961                     xfree(amail); amail = NULL;
1962                     break;
1963                 }
1964             }
1965             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1966                 xfree(aname); aname = NULL;
1967                 xfree(acomment); acomment = NULL;
1968                 xfree(amail); amail = NULL;
1969                 xfree(uid); uid = NULL;
1970                 break;
1971             }
1972             xfree(answer);
1973         }
1974         xfree(answer);
1975         if( !aname && !acomment && !amail )
1976             break;
1977         xfree(uid); uid = NULL;
1978     }
1979     if( uid ) {
1980         char *p = native_to_utf8( uid );
1981         xfree( uid );
1982         uid = p;
1983     }
1984     return uid;
1985 }
1986
1987
1988 /* FIXME: We need a way to cancel this prompt. */
1989 static DEK *
1990 do_ask_passphrase( STRING2KEY **ret_s2k )
1991 {
1992     DEK *dek = NULL;
1993     STRING2KEY *s2k;
1994     const char *errtext = NULL;
1995
1996     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1997
1998     s2k = xmalloc_secure( sizeof *s2k );
1999     for(;;) {
2000         s2k->mode = opt.s2k_mode;
2001         s2k->hash_algo = S2K_DIGEST_ALGO;
2002         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
2003                                  errtext, NULL);
2004         if( !dek ) {
2005             errtext = N_("passphrase not correctly repeated; try again");
2006             tty_printf(_("%s.\n"), _(errtext));
2007         }
2008         else if( !dek->keylen ) {
2009             xfree(dek); dek = NULL;
2010             xfree(s2k); s2k = NULL;
2011             tty_printf(_(
2012             "You don't want a passphrase - this is probably a *bad* idea!\n"
2013             "I will do it anyway.  You can change your passphrase at any time,\n"
2014             "using this program with the option \"--edit-key\".\n\n"));
2015             break;
2016         }
2017         else
2018             break; /* okay */
2019     }
2020     *ret_s2k = s2k;
2021     return dek;
2022 }
2023
2024
2025 static int
2026 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
2027            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 timestamp,
2028            u32 expiredate, int is_subkey )
2029 {
2030   int rc=0;
2031
2032   if( !opt.batch )
2033     tty_printf(_(
2034 "We need to generate a lot of random bytes. It is a good idea to perform\n"
2035 "some other action (type on the keyboard, move the mouse, utilize the\n"
2036 "disks) during the prime generation; this gives the random number\n"
2037 "generator a better chance to gain enough entropy.\n") );
2038
2039   if( algo == PUBKEY_ALGO_ELGAMAL_E )
2040     rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, timestamp,
2041                  expiredate, is_subkey);
2042   else if( algo == PUBKEY_ALGO_DSA )
2043     rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, timestamp,
2044                  expiredate, is_subkey);
2045   else if( algo == PUBKEY_ALGO_RSA )
2046     rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, timestamp,
2047                  expiredate, is_subkey);
2048   else
2049     BUG();
2050
2051   return rc;
2052 }
2053
2054
2055 /****************
2056  * Generate a new user id packet, or return NULL if canceled
2057  */
2058 PKT_user_id *
2059 generate_user_id()
2060 {
2061     PKT_user_id *uid;
2062     char *p;
2063     size_t n;
2064
2065     p = ask_user_id( 1 );
2066     if( !p )
2067         return NULL;
2068     n = strlen(p);
2069     uid = xmalloc_clear( sizeof *uid + n );
2070     uid->len = n;
2071     strcpy(uid->name, p);
2072     uid->ref = 1;
2073     return uid;
2074 }
2075
2076
2077 static void
2078 release_parameter_list( struct para_data_s *r )
2079 {
2080     struct para_data_s *r2;
2081
2082     for( ; r ; r = r2 ) {
2083         r2 = r->next;
2084         if( r->key == pPASSPHRASE_DEK )
2085             xfree( r->u.dek );
2086         else if( r->key == pPASSPHRASE_S2K )
2087             xfree( r->u.s2k );
2088
2089         xfree(r);
2090     }
2091 }
2092
2093 static struct para_data_s *
2094 get_parameter( struct para_data_s *para, enum para_name key )
2095 {
2096     struct para_data_s *r;
2097
2098     for( r = para; r && r->key != key; r = r->next )
2099         ;
2100     return r;
2101 }
2102
2103 static const char *
2104 get_parameter_value( struct para_data_s *para, enum para_name key )
2105 {
2106     struct para_data_s *r = get_parameter( para, key );
2107     return (r && *r->u.value)? r->u.value : NULL;
2108 }
2109
2110 static int
2111 get_parameter_algo( struct para_data_s *para, enum para_name key )
2112 {
2113     int i;
2114     struct para_data_s *r = get_parameter( para, key );
2115     if( !r )
2116         return -1;
2117     if( digitp( r->u.value ) )
2118         i = atoi( r->u.value );
2119     else
2120         i = string_to_pubkey_algo( r->u.value );
2121     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
2122       i = 0; /* we don't want to allow generation of these algorithms */
2123     return i;
2124 }
2125
2126 /*
2127  * parse the usage parameter and set the keyflags.  Return true on error.
2128  */
2129 static int
2130 parse_parameter_usage (const char *fname,
2131                        struct para_data_s *para, enum para_name key)
2132 {
2133     struct para_data_s *r = get_parameter( para, key );
2134     char *p, *pn;
2135     unsigned int use;
2136
2137     if( !r )
2138         return 0; /* none (this is an optional parameter)*/
2139
2140     use = 0;
2141     pn = r->u.value;
2142     while ( (p = strsep (&pn, " \t,")) ) {
2143         if ( !*p)
2144             ;
2145         else if ( !ascii_strcasecmp (p, "sign") )
2146             use |= PUBKEY_USAGE_SIG;
2147         else if ( !ascii_strcasecmp (p, "encrypt") )
2148             use |= PUBKEY_USAGE_ENC;
2149         else if ( !ascii_strcasecmp (p, "auth") )
2150             use |= PUBKEY_USAGE_AUTH;
2151         else {
2152             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
2153             return -1; /* error */
2154         }
2155     }
2156     r->u.usage = use;
2157     return 1;
2158 }
2159
2160 static int
2161 parse_revocation_key (const char *fname,
2162                       struct para_data_s *para, enum para_name key)
2163 {
2164   struct para_data_s *r = get_parameter( para, key );
2165   struct revocation_key revkey;
2166   char *pn;
2167   int i;
2168
2169   if( !r )
2170     return 0; /* none (this is an optional parameter) */
2171
2172   pn = r->u.value;
2173
2174   revkey.class=0x80;
2175   revkey.algid=atoi(pn);
2176   if(!revkey.algid)
2177     goto fail;
2178
2179   /* Skip to the fpr */
2180   while(*pn && *pn!=':')
2181     pn++;
2182
2183   if(*pn!=':')
2184     goto fail;
2185
2186   pn++;
2187
2188   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
2189     {
2190       int c=hextobyte(pn);
2191       if(c==-1)
2192         goto fail;
2193
2194       revkey.fpr[i]=c;
2195     }
2196
2197   /* skip to the tag */
2198   while(*pn && *pn!='s' && *pn!='S')
2199     pn++;
2200
2201   if(ascii_strcasecmp(pn,"sensitive")==0)
2202     revkey.class|=0x40;
2203
2204   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
2205
2206   return 0;
2207
2208   fail:
2209   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
2210   return -1; /* error */
2211 }
2212
2213
2214 static u32
2215 get_parameter_u32( struct para_data_s *para, enum para_name key )
2216 {
2217   struct para_data_s *r;
2218
2219   r = get_parameter (para, key);
2220   if (!r && key == pKEYCREATIONDATE)
2221     {
2222       /* Return a default for the creation date if it has not yet been
2223          set.  We need to set this into the parameter list so that a
2224          second call for pKEYCREATIONDATE returns the same value.  The
2225          default is the current time unless an explicit creation date
2226          has been specified.  Checking the creation date here is only
2227          for the case that it has not yet been parsed. */
2228       r = get_parameter (para, pCREATIONDATE);
2229       if (r && *r->u.value)
2230         {
2231           u32 seconds;
2232
2233           seconds = parse_creation_string (r->u.value);
2234           if (!seconds)
2235             log_error ("invalid creation date in line %d\n", r->lnr );
2236           else /* Okay: Change this parameter. */
2237             {
2238               r->u.creation = seconds;
2239               r->key = pKEYCREATIONDATE;
2240             }
2241         }
2242
2243       r = get_parameter (para, key);
2244       if (!r)
2245         {
2246           /* Create a new parameter. */
2247           r = xmalloc_clear (sizeof *r);
2248           r->key = key;
2249           r->u.creation = make_timestamp ();
2250           r->next = para;
2251           para = r;
2252         }
2253
2254       r = get_parameter (para, key);
2255       assert (r);
2256     }
2257
2258
2259     if (!r)
2260       return 0;
2261     if( r->key == pKEYCREATIONDATE )
2262       return r->u.creation;
2263     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
2264         return r->u.expire;
2265     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
2266         return r->u.usage;
2267
2268     return (unsigned int)strtoul( r->u.value, NULL, 10 );
2269 }
2270
2271 static unsigned int
2272 get_parameter_uint( struct para_data_s *para, enum para_name key )
2273 {
2274     return get_parameter_u32( para, key );
2275 }
2276
2277 static DEK *
2278 get_parameter_dek( struct para_data_s *para, enum para_name key )
2279 {
2280     struct para_data_s *r = get_parameter( para, key );
2281     return r? r->u.dek : NULL;
2282 }
2283
2284 static STRING2KEY *
2285 get_parameter_s2k( struct para_data_s *para, enum para_name key )
2286 {
2287     struct para_data_s *r = get_parameter( para, key );
2288     return r? r->u.s2k : NULL;
2289 }
2290
2291 static struct revocation_key *
2292 get_parameter_revkey( struct para_data_s *para, enum para_name key )
2293 {
2294     struct para_data_s *r = get_parameter( para, key );
2295     return r? &r->u.revkey : NULL;
2296 }
2297
2298 static int
2299 proc_parameter_file( struct para_data_s *para, const char *fname,
2300                      struct output_control_s *outctrl, int card )
2301 {
2302   struct para_data_s *r;
2303   const char *s1, *s2, *s3;
2304   size_t n;
2305   char *p;
2306   int have_user_id=0,err,algo;
2307
2308   /* Check that we have all required parameters. */
2309   r = get_parameter( para, pKEYTYPE );
2310   if(r)
2311     {
2312       algo=get_parameter_algo(para,pKEYTYPE);
2313       if(check_pubkey_algo2(algo,PUBKEY_USAGE_SIG))
2314         {
2315           log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
2316           return -1;
2317         }
2318     }
2319   else
2320     {
2321       log_error("%s: no Key-Type specified\n",fname);
2322       return -1;
2323     }
2324
2325   err = parse_parameter_usage (fname, para, pKEYUSAGE);
2326   if (!err)
2327     {
2328       /* Default to algo capabilities if key-usage is not provided */
2329       r = xmalloc_clear(sizeof(*r));
2330       r->key = pKEYUSAGE;
2331       r->u.usage = openpgp_pk_algo_usage(algo);
2332       r->next = para;
2333       para = r;
2334     }
2335   else if (err == -1)
2336     return -1;
2337   else
2338     {
2339       r = get_parameter (para, pKEYUSAGE);
2340       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2341         {
2342           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
2343                      fname, r->lnr, algo);
2344           return -1;
2345         }
2346     }
2347
2348   r = get_parameter( para, pSUBKEYTYPE );
2349   if(r)
2350     {
2351       algo = get_parameter_algo (para, pSUBKEYTYPE);
2352       if (check_pubkey_algo (algo))
2353         {
2354           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
2355           return -1;
2356         }
2357
2358       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
2359       if (!err)
2360         {
2361           /* Default to algo capabilities if subkey-usage is not
2362              provided */
2363           r = xmalloc_clear (sizeof(*r));
2364           r->key = pSUBKEYUSAGE;
2365           r->u.usage = openpgp_pk_algo_usage (algo);
2366           r->next = para;
2367           para = r;
2368         }
2369       else if (err == -1)
2370         return -1;
2371       else
2372         {
2373           r = get_parameter (para, pSUBKEYUSAGE);
2374           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
2375             {
2376               log_error ("%s:%d: specified Subkey-Usage not allowed"
2377                          " for algo %d\n", fname, r->lnr, algo);
2378               return -1;
2379             }
2380         }
2381     }
2382
2383   if( get_parameter_value( para, pUSERID ) )
2384     have_user_id=1;
2385   else
2386     {
2387       /* create the formatted user ID */
2388       s1 = get_parameter_value( para, pNAMEREAL );
2389       s2 = get_parameter_value( para, pNAMECOMMENT );
2390       s3 = get_parameter_value( para, pNAMEEMAIL );
2391       if( s1 || s2 || s3 )
2392         {
2393           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
2394           r = xmalloc_clear( sizeof *r + n + 20 );
2395           r->key = pUSERID;
2396           p = r->u.value;
2397           if( s1 )
2398             p = stpcpy(p, s1 );
2399           if( s2 )
2400             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
2401           if( s3 )
2402             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
2403           r->next = para;
2404           para = r;
2405           have_user_id=1;
2406         }
2407     }
2408
2409   if(!have_user_id)
2410     {
2411       log_error("%s: no User-ID specified\n",fname);
2412       return -1;
2413     }
2414
2415   /* Set preferences, if any. */
2416   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
2417
2418   /* Set keyserver, if any. */
2419   s1=get_parameter_value( para, pKEYSERVER );
2420   if(s1)
2421     {
2422       struct keyserver_spec *spec;
2423
2424       spec=parse_keyserver_uri(s1,1,NULL,0);
2425       if(spec)
2426         {
2427           free_keyserver_spec(spec);
2428           opt.def_keyserver_url=s1;
2429         }
2430       else
2431         {
2432           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
2433           return -1;
2434         }
2435     }
2436
2437   /* Set revoker, if any. */
2438   if (parse_revocation_key (fname, para, pREVOKER))
2439     return -1;
2440
2441   /* make DEK and S2K from the Passphrase */
2442   r = get_parameter( para, pPASSPHRASE );
2443   if( r && *r->u.value ) {
2444     /* We have a plain text passphrase - create a DEK from it.
2445      * It is a little bit ridiculous to keep it in secure memory
2446      * but because we do this alwasy, why not here.  */
2447     STRING2KEY *s2k;
2448     DEK *dek;
2449
2450     s2k = xmalloc_secure( sizeof *s2k );
2451     s2k->mode = opt.s2k_mode;
2452     s2k->hash_algo = S2K_DIGEST_ALGO;
2453     set_next_passphrase( r->u.value );
2454     dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2455                              NULL, NULL);
2456     set_next_passphrase( NULL );
2457     assert( dek );
2458     memset( r->u.value, 0, strlen(r->u.value) );
2459
2460     r = xmalloc_clear( sizeof *r );
2461     r->key = pPASSPHRASE_S2K;
2462     r->u.s2k = s2k;
2463     r->next = para;
2464     para = r;
2465     r = xmalloc_clear( sizeof *r );
2466     r->key = pPASSPHRASE_DEK;
2467     r->u.dek = dek;
2468     r->next = para;
2469     para = r;
2470   }
2471
2472   /* Make KEYCREATIONDATE from Creation-Date.  */
2473   r = get_parameter (para, pCREATIONDATE);
2474   if (r && *r->u.value)
2475     {
2476       u32 seconds;
2477
2478       seconds = parse_creation_string (r->u.value);
2479       if (!seconds)
2480         {
2481           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
2482           return -1;
2483         }
2484       r->u.creation = seconds;
2485       r->key = pKEYCREATIONDATE;  /* Change that entry. */
2486     }
2487
2488   /* Make KEYEXPIRE from Expire-Date.  */
2489   r = get_parameter( para, pEXPIREDATE );
2490   if( r && *r->u.value )
2491     {
2492       u32 seconds;
2493
2494       seconds = parse_expire_string
2495         (get_parameter_u32 (para, pKEYCREATIONDATE), r->u.value);
2496       if (seconds == (u32)(-1))
2497         {
2498           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
2499           return -1;
2500         }
2501       r->u.expire = seconds;
2502       r->key = pKEYEXPIRE;  /* change hat entry */
2503       /* also set it for the subkey */
2504       r = xmalloc_clear( sizeof *r + 20 );
2505       r->key = pSUBKEYEXPIRE;
2506       r->u.expire = seconds;
2507       r->next = para;
2508       para = r;
2509     }
2510
2511   if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
2512     log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
2513     return -1;
2514   }
2515
2516   do_generate_keypair (para, outctrl, card);
2517   return 0;
2518 }
2519
2520
2521 /****************
2522  * Kludge to allow non interactive key generation controlled
2523  * by a parameter file.
2524  * Note, that string parameters are expected to be in UTF-8
2525  */
2526 static void
2527 read_parameter_file( const char *fname )
2528 {
2529     static struct { const char *name;
2530                     enum para_name key;
2531     } keywords[] = {
2532         { "Key-Type",       pKEYTYPE},
2533         { "Key-Length",     pKEYLENGTH },
2534         { "Key-Usage",      pKEYUSAGE },
2535         { "Subkey-Type",    pSUBKEYTYPE },
2536         { "Subkey-Length",  pSUBKEYLENGTH },
2537         { "Subkey-Usage",   pSUBKEYUSAGE },
2538         { "Name-Real",      pNAMEREAL },
2539         { "Name-Email",     pNAMEEMAIL },
2540         { "Name-Comment",   pNAMECOMMENT },
2541         { "Expire-Date",    pEXPIREDATE },
2542         { "Creation-Date",  pCREATIONDATE },
2543         { "Passphrase",     pPASSPHRASE },
2544         { "Preferences",    pPREFERENCES },
2545         { "Revoker",        pREVOKER },
2546         { "Handle",         pHANDLE },
2547         { "Keyserver",      pKEYSERVER },
2548         { NULL, 0 }
2549     };
2550     IOBUF fp;
2551     byte *line;
2552     unsigned int maxlen, nline;
2553     char *p;
2554     int lnr;
2555     const char *err = NULL;
2556     struct para_data_s *para, *r;
2557     int i;
2558     struct output_control_s outctrl;
2559
2560     memset( &outctrl, 0, sizeof( outctrl ) );
2561
2562     if( !fname || !*fname)
2563       fname = "-";
2564
2565     fp = iobuf_open (fname);
2566     if (fp && is_secured_file (iobuf_get_fd (fp)))
2567       {
2568         iobuf_close (fp);
2569         fp = NULL;
2570         errno = EPERM;
2571       }
2572     if (!fp) {
2573       log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
2574       return;
2575     }
2576     iobuf_ioctl (fp, 3, 1, NULL); /* No file caching. */
2577
2578     lnr = 0;
2579     err = NULL;
2580     para = NULL;
2581     maxlen = 1024;
2582     line = NULL;
2583     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
2584         char *keyword, *value;
2585
2586         lnr++;
2587         if( !maxlen ) {
2588             err = "line too long";
2589             break;
2590         }
2591         for( p = line; isspace(*(byte*)p); p++ )
2592             ;
2593         if( !*p || *p == '#' )
2594             continue;
2595         keyword = p;
2596         if( *keyword == '%' ) {
2597             for( ; !isspace(*(byte*)p); p++ )
2598                 ;
2599             if( *p )
2600                 *p++ = 0;
2601             for( ; isspace(*(byte*)p); p++ )
2602                 ;
2603             value = p;
2604             trim_trailing_ws( value, strlen(value) );
2605             if( !ascii_strcasecmp( keyword, "%echo" ) )
2606                 log_info("%s\n", value );
2607             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
2608                 outctrl.dryrun = 1;
2609             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
2610                 outctrl.lnr = lnr;
2611                 if (proc_parameter_file( para, fname, &outctrl, 0 ))
2612                   print_status_key_not_created
2613                     (get_parameter_value (para, pHANDLE));
2614                 release_parameter_list( para );
2615                 para = NULL;
2616             }
2617             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
2618                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
2619                     ; /* still the same file - ignore it */
2620                 else {
2621                     xfree( outctrl.pub.newfname );
2622                     outctrl.pub.newfname = xstrdup( value );
2623                     outctrl.use_files = 1;
2624                 }
2625             }
2626             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
2627                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
2628                     ; /* still the same file - ignore it */
2629                 else {
2630                    xfree( outctrl.sec.newfname );
2631                    outctrl.sec.newfname = xstrdup( value );
2632                    outctrl.use_files = 1;
2633                 }
2634             }
2635             else
2636                 log_info("skipping control `%s' (%s)\n", keyword, value );
2637
2638
2639             continue;
2640         }
2641
2642
2643         if( !(p = strchr( p, ':' )) || p == keyword ) {
2644             err = "missing colon";
2645             break;
2646         }
2647         if( *p )
2648             *p++ = 0;
2649         for( ; isspace(*(byte*)p); p++ )
2650             ;
2651         if( !*p ) {
2652             err = "missing argument";
2653             break;
2654         }
2655         value = p;
2656         trim_trailing_ws( value, strlen(value) );
2657
2658         for(i=0; keywords[i].name; i++ ) {
2659             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2660                 break;
2661         }
2662         if( !keywords[i].name ) {
2663             err = "unknown keyword";
2664             break;
2665         }
2666         if( keywords[i].key != pKEYTYPE && !para ) {
2667             err = "parameter block does not start with \"Key-Type\"";
2668             break;
2669         }
2670
2671         if( keywords[i].key == pKEYTYPE && para ) {
2672             outctrl.lnr = lnr;
2673             if (proc_parameter_file( para, fname, &outctrl, 0 ))
2674               print_status_key_not_created
2675                 (get_parameter_value (para, pHANDLE));
2676             release_parameter_list( para );
2677             para = NULL;
2678         }
2679         else {
2680             for( r = para; r; r = r->next ) {
2681                 if( r->key == keywords[i].key )
2682                     break;
2683             }
2684             if( r ) {
2685                 err = "duplicate keyword";
2686                 break;
2687             }
2688         }
2689         r = xmalloc_clear( sizeof *r + strlen( value ) );
2690         r->lnr = lnr;
2691         r->key = keywords[i].key;
2692         strcpy( r->u.value, value );
2693         r->next = para;
2694         para = r;
2695     }
2696     if( err )
2697         log_error("%s:%d: %s\n", fname, lnr, err );
2698     else if( iobuf_error (fp) ) {
2699         log_error("%s:%d: read error\n", fname, lnr);
2700     }
2701     else if( para ) {
2702         outctrl.lnr = lnr;
2703         if (proc_parameter_file( para, fname, &outctrl, 0 ))
2704           print_status_key_not_created (get_parameter_value (para, pHANDLE));
2705     }
2706
2707     if( outctrl.use_files ) { /* close open streams */
2708         iobuf_close( outctrl.pub.stream );
2709         iobuf_close( outctrl.sec.stream );
2710
2711         /* Must invalidate that ugly cache to actually close it.  */
2712         if (outctrl.pub.fname)
2713           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.pub.fname);
2714         if (outctrl.sec.fname)
2715           iobuf_ioctl (NULL, 2, 0, (char*)outctrl.sec.fname);
2716
2717         xfree( outctrl.pub.fname );
2718         xfree( outctrl.pub.newfname );
2719         xfree( outctrl.sec.fname );
2720         xfree( outctrl.sec.newfname );
2721     }
2722
2723     release_parameter_list( para );
2724     iobuf_close (fp);
2725 }
2726
2727
2728 /*
2729  * Generate a keypair (fname is only used in batch mode) If
2730  * CARD_SERIALNO is not NULL the fucntion will create the keys on an
2731  * OpenPGP Card.  If BACKUP_ENCRYPTION_DIR has been set and
2732  * CARD_SERIALNO is NOT NULL, the encryption key for the card gets
2733  * generate in software, imported to the card and a backup file
2734  * written to directory given by this argument .
2735  */
2736 void
2737 generate_keypair (const char *fname, const char *card_serialno,
2738                   const char *backup_encryption_dir)
2739 {
2740   unsigned int nbits;
2741   char *uid = NULL;
2742   DEK *dek;
2743   STRING2KEY *s2k;
2744   int algo;
2745   unsigned int use;
2746   int both = 0;
2747   u32 expire;
2748   struct para_data_s *para = NULL;
2749   struct para_data_s *r;
2750   struct output_control_s outctrl;
2751
2752   memset( &outctrl, 0, sizeof( outctrl ) );
2753
2754   if (opt.batch && card_serialno)
2755     {
2756       /* We don't yet support unattended key generation. */
2757       log_error (_("can't do this in batch mode\n"));
2758       return;
2759     }
2760
2761   if (opt.batch)
2762     {
2763       read_parameter_file( fname );
2764       return;
2765     }
2766
2767   if (card_serialno)
2768     {
2769 #ifdef ENABLE_CARD_SUPPORT
2770       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2771       r->key = pSERIALNO;
2772       strcpy( r->u.value, card_serialno);
2773       r->next = para;
2774       para = r;
2775
2776       algo = PUBKEY_ALGO_RSA;
2777
2778       r = xcalloc (1, sizeof *r + 20 );
2779       r->key = pKEYTYPE;
2780       sprintf( r->u.value, "%d", algo );
2781       r->next = para;
2782       para = r;
2783       r = xcalloc (1, sizeof *r + 20 );
2784       r->key = pKEYUSAGE;
2785       strcpy (r->u.value, "sign");
2786       r->next = para;
2787       para = r;
2788
2789       r = xcalloc (1, sizeof *r + 20 );
2790       r->key = pSUBKEYTYPE;
2791       sprintf( r->u.value, "%d", algo );
2792       r->next = para;
2793       para = r;
2794       r = xcalloc (1, sizeof *r + 20 );
2795       r->key = pSUBKEYUSAGE;
2796       strcpy (r->u.value, "encrypt");
2797       r->next = para;
2798       para = r;
2799
2800       r = xcalloc (1, sizeof *r + 20 );
2801       r->key = pAUTHKEYTYPE;
2802       sprintf( r->u.value, "%d", algo );
2803       r->next = para;
2804       para = r;
2805
2806       if (backup_encryption_dir)
2807         {
2808           r = xcalloc (1, sizeof *r + strlen (backup_encryption_dir) );
2809           r->key = pBACKUPENCDIR;
2810           strcpy (r->u.value, backup_encryption_dir);
2811           r->next = para;
2812           para = r;
2813         }
2814 #endif /*ENABLE_CARD_SUPPORT*/
2815     }
2816   else
2817     {
2818       int subkey_algo;
2819
2820       algo = ask_algo (0, &subkey_algo, &use );
2821       if (subkey_algo)
2822         {
2823           /* Create primary and subkey at once.  */
2824           both = 1;
2825           r = xmalloc_clear( sizeof *r + 20 );
2826           r->key = pKEYTYPE;
2827           sprintf (r->u.value, "%d", algo);
2828           r->next = para;
2829           para = r;
2830           nbits = ask_keysize (algo, 0);
2831           r = xmalloc_clear( sizeof *r + 20 );
2832           r->key = pKEYLENGTH;
2833           sprintf( r->u.value, "%u", nbits);
2834           r->next = para;
2835           para = r;
2836           r = xmalloc_clear( sizeof *r + 20 );
2837           r->key = pKEYUSAGE;
2838           strcpy( r->u.value, "sign" );
2839           r->next = para;
2840           para = r;
2841
2842           r = xmalloc_clear( sizeof *r + 20 );
2843           r->key = pSUBKEYTYPE;
2844           sprintf( r->u.value, "%d", subkey_algo );
2845           r->next = para;
2846           para = r;
2847           r = xmalloc_clear( sizeof *r + 20 );
2848           r->key = pSUBKEYUSAGE;
2849           strcpy( r->u.value, "encrypt" );
2850           r->next = para;
2851           para = r;
2852         }
2853       else
2854         {
2855           r = xmalloc_clear( sizeof *r + 20 );
2856           r->key = pKEYTYPE;
2857           sprintf( r->u.value, "%d", algo );
2858           r->next = para;
2859           para = r;
2860
2861           if (use)
2862             {
2863               r = xmalloc_clear( sizeof *r + 25 );
2864               r->key = pKEYUSAGE;
2865               sprintf( r->u.value, "%s%s%s",
2866                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
2867                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
2868                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
2869               r->next = para;
2870               para = r;
2871             }
2872           nbits = 0;
2873         }
2874
2875       nbits = ask_keysize (both? subkey_algo : algo, nbits);
2876       r = xmalloc_clear( sizeof *r + 20 );
2877       r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2878       sprintf( r->u.value, "%u", nbits);
2879       r->next = para;
2880       para = r;
2881     }
2882
2883   expire = ask_expire_interval (get_parameter_u32 (para, pKEYCREATIONDATE),
2884                                 0, NULL);
2885   r = xmalloc_clear( sizeof *r + 20 );
2886   r->key = pKEYEXPIRE;
2887   r->u.expire = expire;
2888   r->next = para;
2889   para = r;
2890   r = xmalloc_clear( sizeof *r + 20 );
2891   r->key = pSUBKEYEXPIRE;
2892   r->u.expire = expire;
2893   r->next = para;
2894   para = r;
2895
2896   uid = ask_user_id(0);
2897   if( !uid )
2898     {
2899       log_error(_("Key generation canceled.\n"));
2900       release_parameter_list( para );
2901       return;
2902     }
2903   r = xmalloc_clear( sizeof *r + strlen(uid) );
2904   r->key = pUSERID;
2905   strcpy( r->u.value, uid );
2906   r->next = para;
2907   para = r;
2908
2909   dek = card_serialno? NULL : do_ask_passphrase( &s2k );
2910   if( dek )
2911     {
2912       r = xmalloc_clear( sizeof *r );
2913       r->key = pPASSPHRASE_DEK;
2914       r->u.dek = dek;
2915       r->next = para;
2916       para = r;
2917       r = xmalloc_clear( sizeof *r );
2918       r->key = pPASSPHRASE_S2K;
2919       r->u.s2k = s2k;
2920       r->next = para;
2921       para = r;
2922     }
2923
2924   proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
2925   release_parameter_list( para );
2926 }
2927
2928
2929 #ifdef ENABLE_CARD_SUPPORT
2930 /* Generate a raw key and return it as a secret key packet.  The
2931    function will ask for the passphrase and return a protected as well
2932    as an unprotected copy of a new secret key packet.  0 is returned
2933    on success and the caller must then free the returned values.  */
2934 static int
2935 generate_raw_key (int algo, unsigned int nbits, u32 created_at,
2936                   PKT_secret_key **r_sk_unprotected,
2937                   PKT_secret_key **r_sk_protected)
2938 {
2939   int rc;
2940   DEK *dek = NULL;
2941   STRING2KEY *s2k = NULL;
2942   PKT_secret_key *sk = NULL;
2943   int i;
2944   size_t nskey, npkey;
2945
2946   npkey = pubkey_get_npkey (algo);
2947   nskey = pubkey_get_nskey (algo);
2948   assert (nskey <= PUBKEY_MAX_NSKEY && npkey < nskey);
2949
2950   if (nbits < 512)
2951     {
2952       nbits = 512;
2953       log_info (_("keysize invalid; using %u bits\n"), nbits );
2954     }
2955
2956   if ((nbits % 32))
2957     {
2958       nbits = ((nbits + 31) / 32) * 32;
2959       log_info(_("keysize rounded up to %u bits\n"), nbits );
2960     }
2961
2962   dek = do_ask_passphrase (&s2k);
2963
2964   sk = xmalloc_clear (sizeof *sk);
2965   sk->timestamp = created_at;
2966   sk->version = 4;
2967   sk->pubkey_algo = algo;
2968
2969   rc = pubkey_generate (algo, nbits, sk->skey, NULL);
2970   if (rc)
2971     {
2972       log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
2973       goto leave;
2974     }
2975
2976   for (i=npkey; i < nskey; i++)
2977     sk->csum += checksum_mpi (sk->skey[i]);
2978
2979   if (r_sk_unprotected)
2980     *r_sk_unprotected = copy_secret_key (NULL, sk);
2981
2982   if (dek)
2983     {
2984       sk->protect.algo = dek->algo;
2985       sk->protect.s2k = *s2k;
2986       rc = protect_secret_key (sk, dek);
2987       if (rc)
2988         {
2989           log_error ("protect_secret_key failed: %s\n", g10_errstr(rc));
2990           goto leave;
2991         }
2992     }
2993   if (r_sk_protected)
2994     {
2995       *r_sk_protected = sk;
2996       sk = NULL;
2997     }
2998
2999  leave:
3000   if (sk)
3001     free_secret_key (sk);
3002   xfree (dek);
3003   xfree (s2k);
3004   return rc;
3005 }
3006 #endif /* ENABLE_CARD_SUPPORT */
3007
3008 /* Create and delete a dummy packet to start off a list of kbnodes. */
3009 static void
3010 start_tree(KBNODE *tree)
3011 {
3012   PACKET *pkt;
3013
3014   pkt=xmalloc_clear(sizeof(*pkt));
3015   pkt->pkttype=PKT_NONE;
3016   *tree=new_kbnode(pkt);
3017   delete_kbnode(*tree);
3018 }
3019
3020 static void
3021 do_generate_keypair (struct para_data_s *para,struct output_control_s *outctrl,
3022                      int card)
3023 {
3024     KBNODE pub_root = NULL;
3025     KBNODE sec_root = NULL;
3026     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3027     const char *s;
3028     struct revocation_key *revkey;
3029     int rc;
3030     int did_sub = 0;
3031     u32 timestamp;
3032
3033     if( outctrl->dryrun )
3034       {
3035         log_info("dry-run mode - key generation skipped\n");
3036         return;
3037       }
3038
3039     if( outctrl->use_files ) {
3040         if( outctrl->pub.newfname ) {
3041             iobuf_close(outctrl->pub.stream);
3042             outctrl->pub.stream = NULL;
3043             if (outctrl->pub.fname)
3044               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->pub.fname);
3045             xfree( outctrl->pub.fname );
3046             outctrl->pub.fname =  outctrl->pub.newfname;
3047             outctrl->pub.newfname = NULL;
3048
3049             if (is_secured_filename (outctrl->pub.fname) ) {
3050                 outctrl->pub.stream = NULL;
3051                 errno = EPERM;
3052             }
3053             else
3054                 outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
3055             if( !outctrl->pub.stream ) {
3056                 log_error(_("can't create `%s': %s\n"), outctrl->pub.newfname,
3057                                                      strerror(errno) );
3058                 return;
3059             }
3060             if( opt.armor ) {
3061                 outctrl->pub.afx.what = 1;
3062                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
3063                                                     &outctrl->pub.afx );
3064             }
3065         }
3066         if( outctrl->sec.newfname ) {
3067             mode_t oldmask;
3068
3069             iobuf_close(outctrl->sec.stream);
3070             outctrl->sec.stream = NULL;
3071             if (outctrl->sec.fname)
3072               iobuf_ioctl (NULL, 2, 0, (char*)outctrl->sec.fname);
3073             xfree( outctrl->sec.fname );
3074             outctrl->sec.fname =  outctrl->sec.newfname;
3075             outctrl->sec.newfname = NULL;
3076
3077             oldmask = umask (077);
3078             if (is_secured_filename (outctrl->sec.fname) ) {
3079                 outctrl->sec.stream = NULL;
3080                 errno = EPERM;
3081             }
3082             else
3083                 outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
3084             umask (oldmask);
3085             if( !outctrl->sec.stream ) {
3086                 log_error(_("can't create `%s': %s\n"), outctrl->sec.newfname,
3087                                                      strerror(errno) );
3088                 return;
3089             }
3090             if( opt.armor ) {
3091                 outctrl->sec.afx.what = 5;
3092                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
3093                                                     &outctrl->sec.afx );
3094             }
3095         }
3096         assert( outctrl->pub.stream );
3097         assert( outctrl->sec.stream );
3098         if( opt.verbose ) {
3099             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
3100             if (card)
3101               log_info (_("writing secret key stub to `%s'\n"),
3102                         outctrl->sec.fname);
3103             else
3104               log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
3105         }
3106     }
3107
3108
3109     /* We create the packets as a tree of kbnodes. Because the
3110      * structure we create is known in advance we simply generate a
3111      * linked list.  The first packet is a dummy packet which we flag
3112      * as deleted.  The very first packet must always be a KEY packet.
3113      */
3114
3115     start_tree(&pub_root);
3116     start_tree(&sec_root);
3117
3118     timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
3119
3120     /* Note that, depending on the backend (i.e. the used scdaemon
3121        version or the internal code), the card key generation may
3122        update TIMESTAMP for each key.  Thus we need to pass TIMESTAMP
3123        to all signing function to make sure that the binding signature
3124        is done using the timestamp of the corresponding (sub)key and
3125        not that of the primary key.  An alternative implementation
3126        could tell the signing function the node of the subkey but that
3127        is more work than just to pass the current timestamp.  */
3128
3129     if (!card)
3130       {
3131         rc = do_create( get_parameter_algo( para, pKEYTYPE ),
3132                         get_parameter_uint( para, pKEYLENGTH ),
3133                         pub_root, sec_root,
3134                         get_parameter_dek( para, pPASSPHRASE_DEK ),
3135                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
3136                         &pri_sk,
3137                         timestamp,
3138                         get_parameter_u32( para, pKEYEXPIRE ), 0 );
3139       }
3140     else
3141       {
3142         rc = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root, sec_root, NULL,
3143                            &timestamp,
3144                            get_parameter_u32 (para, pKEYEXPIRE), para);
3145         if (!rc)
3146           {
3147             pri_sk = sec_root->next->pkt->pkt.secret_key;
3148             assert (pri_sk);
3149           }
3150       }
3151
3152     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
3153       {
3154         rc = write_direct_sig (pub_root, pub_root, pri_sk, revkey, timestamp);
3155         if (!rc)
3156           write_direct_sig (sec_root, pub_root, pri_sk, revkey, timestamp);
3157       }
3158
3159     if( !rc && (s=get_parameter_value(para, pUSERID)) )
3160       {
3161         write_uid(pub_root, s );
3162         if( !rc )
3163           write_uid(sec_root, s );
3164
3165         if (!rc)
3166           rc = write_selfsigs (sec_root, pub_root, pri_sk,
3167                                get_parameter_uint (para, pKEYUSAGE),
3168                                timestamp);
3169       }
3170
3171     /* Write the auth key to the card before the encryption key.  This
3172        is a partial workaround for a PGP bug (as of this writing, all
3173        versions including 8.1), that causes it to try and encrypt to
3174        the most recent subkey regardless of whether that subkey is
3175        actually an encryption type.  In this case, the auth key is an
3176        RSA key so it succeeds. */
3177
3178     if (!rc && card && get_parameter (para, pAUTHKEYTYPE))
3179       {
3180         rc = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root, sec_root, NULL,
3181                            &timestamp,
3182                            get_parameter_u32 (para, pKEYEXPIRE), para);
3183
3184         if (!rc)
3185           rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk,
3186                                  PUBKEY_USAGE_AUTH, timestamp);
3187         if (!rc)
3188           rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk,
3189                                  PUBKEY_USAGE_AUTH, timestamp);
3190       }
3191
3192     if( !rc && get_parameter( para, pSUBKEYTYPE ) )
3193       {
3194         if (!card)
3195           {
3196             rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
3197                             get_parameter_uint( para, pSUBKEYLENGTH ),
3198                             pub_root, sec_root,
3199                             get_parameter_dek( para, pPASSPHRASE_DEK ),
3200                             get_parameter_s2k( para, pPASSPHRASE_S2K ),
3201                             &sub_sk,
3202                             timestamp,
3203                             get_parameter_u32( para, pSUBKEYEXPIRE ), 1 );
3204           }
3205         else
3206           {
3207             if ((s = get_parameter_value (para, pBACKUPENCDIR)))
3208               {
3209                 /* A backup of the encryption key has been requested.
3210                    Generate the key i software and import it then to
3211                    the card.  Write a backup file. */
3212                 rc = gen_card_key_with_backup (PUBKEY_ALGO_RSA, 2, 0,
3213                                                pub_root, sec_root,
3214                                                timestamp,
3215                                                get_parameter_u32 (para,
3216                                                                   pKEYEXPIRE),
3217                                                para, s);
3218               }
3219             else
3220               rc = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, sec_root,
3221                                  NULL,
3222                                  &timestamp,
3223                                  get_parameter_u32 (para, pKEYEXPIRE), para);
3224           }
3225
3226         if( !rc )
3227           rc = write_keybinding (pub_root, pub_root, pri_sk, sub_sk,
3228                                  get_parameter_uint (para, pSUBKEYUSAGE),
3229                                  timestamp );
3230         if( !rc )
3231           rc = write_keybinding (sec_root, pub_root, pri_sk, sub_sk,
3232                                  get_parameter_uint (para, pSUBKEYUSAGE),
3233                                  timestamp);
3234         did_sub = 1;
3235       }
3236
3237     if( !rc && outctrl->use_files ) { /* direct write to specified files */
3238         rc = write_keyblock( outctrl->pub.stream, pub_root );
3239         if( rc )
3240             log_error("can't write public key: %s\n", g10_errstr(rc) );
3241         if( !rc ) {
3242             rc = write_keyblock( outctrl->sec.stream, sec_root );
3243             if( rc )
3244                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
3245         }
3246
3247     }
3248     else if( !rc ) { /* write to the standard keyrings */
3249         KEYDB_HANDLE pub_hd = keydb_new (0);
3250         KEYDB_HANDLE sec_hd = keydb_new (1);
3251
3252         /* FIXME: we may have to create the keyring first */
3253         rc = keydb_locate_writable (pub_hd, NULL);
3254         if (rc)
3255             log_error (_("no writable public keyring found: %s\n"),
3256                        g10_errstr (rc));
3257
3258         if (!rc) {
3259             rc = keydb_locate_writable (sec_hd, NULL);
3260             if (rc)
3261                 log_error (_("no writable secret keyring found: %s\n"),
3262                            g10_errstr (rc));
3263         }
3264
3265         if (!rc && opt.verbose) {
3266             log_info(_("writing public key to `%s'\n"),
3267                      keydb_get_resource_name (pub_hd));
3268             if (card)
3269               log_info (_("writing secret key stub to `%s'\n"),
3270                         keydb_get_resource_name (sec_hd));
3271             else
3272               log_info(_("writing secret key to `%s'\n"),
3273                        keydb_get_resource_name (sec_hd));
3274         }
3275
3276         if (!rc) {
3277             rc = keydb_insert_keyblock (pub_hd, pub_root);
3278             if (rc)
3279                 log_error (_("error writing public keyring `%s': %s\n"),
3280                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
3281         }
3282
3283         if (!rc) {
3284             rc = keydb_insert_keyblock (sec_hd, sec_root);
3285             if (rc)
3286                 log_error (_("error writing secret keyring `%s': %s\n"),
3287                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
3288         }
3289
3290         keydb_release (pub_hd);
3291         keydb_release (sec_hd);
3292
3293         if (!rc) {
3294             int no_enc_rsa =
3295                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
3296                 && get_parameter_uint( para, pKEYUSAGE )
3297                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
3298             PKT_public_key *pk = find_kbnode (pub_root,
3299                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3300
3301             keyid_from_pk(pk,pk->main_keyid);
3302             register_trusted_keyid(pk->main_keyid);
3303
3304             update_ownertrust (pk,
3305                                ((get_ownertrust (pk) & ~TRUST_MASK)
3306                                 | TRUST_ULTIMATE ));
3307
3308             if (!opt.batch) {
3309                 tty_printf(_("public and secret key created and signed.\n") );
3310                 tty_printf("\n");
3311                 list_keyblock(pub_root,0,1,NULL);
3312             }
3313
3314
3315             if( !opt.batch
3316                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
3317                      || no_enc_rsa )
3318                 && !get_parameter( para, pSUBKEYTYPE ) )
3319             {
3320                 tty_printf(_("Note that this key cannot be used for "
3321                              "encryption.  You may want to use\n"
3322                              "the command \"--edit-key\" to generate a "
3323                              "subkey for this purpose.\n") );
3324             }
3325         }
3326     }
3327
3328     if( rc ) {
3329         if( opt.batch )
3330             log_error("key generation failed: %s\n", g10_errstr(rc) );
3331         else
3332             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
3333         print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
3334     }
3335     else {
3336         PKT_public_key *pk = find_kbnode (pub_root,
3337                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
3338         print_status_key_created (did_sub? 'B':'P', pk,
3339                                   get_parameter_value (para, pHANDLE));
3340     }
3341     release_kbnode( pub_root );
3342     release_kbnode( sec_root );
3343
3344     if( pri_sk && !card) /* the unprotected  secret key unless we have a */
3345       free_secret_key(pri_sk); /* shallow copy in card mode. */
3346     if( sub_sk )
3347         free_secret_key(sub_sk);
3348 }
3349
3350
3351 /****************
3352  * add a new subkey to an existing key.
3353  * Returns true if a new key has been generated and put into the keyblocks.
3354  */
3355 int
3356 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
3357 {
3358     int okay=0, rc=0;
3359     KBNODE node;
3360     PKT_secret_key *pri_sk = NULL, *sub_sk = NULL;
3361     int algo;
3362     unsigned int use;
3363     u32 expire;
3364     unsigned nbits;
3365     char *passphrase = NULL;
3366     DEK *dek = NULL;
3367     STRING2KEY *s2k = NULL;
3368     u32 timestamp;
3369     int ask_pass = 0;
3370
3371     /* break out the primary secret key */
3372     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3373     if( !node ) {
3374         log_error("Oops; secret key not found anymore!\n");
3375         goto leave;
3376     }
3377
3378     /* make a copy of the sk to keep the protected one in the keyblock */
3379     pri_sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
3380
3381     timestamp = make_timestamp();
3382     if( pri_sk->timestamp > timestamp ) {
3383         ulong d = pri_sk->timestamp - timestamp;
3384         log_info( d==1 ? _("key has been created %lu second "
3385                            "in future (time warp or clock problem)\n")
3386                        : _("key has been created %lu seconds "
3387                            "in future (time warp or clock problem)\n"), d );
3388         if( !opt.ignore_time_conflict ) {
3389             rc = G10ERR_TIME_CONFLICT;
3390             goto leave;
3391         }
3392     }
3393
3394     if (pri_sk->version < 4) {
3395         log_info (_("NOTE: creating subkeys for v3 keys "
3396                     "is not OpenPGP compliant\n"));
3397         goto leave;
3398     }
3399
3400     if (pri_sk->is_protected && pri_sk->protect.s2k.mode == 1001) {
3401         tty_printf(_("Secret parts of primary key are not available.\n"));
3402         rc = G10ERR_NO_SECKEY;
3403         goto leave;
3404     }
3405
3406
3407     /* Unprotect to get the passphrase.  */
3408     switch( is_secret_key_protected( pri_sk ) ) {
3409       case -1:
3410         rc = G10ERR_PUBKEY_ALGO;
3411         break;
3412       case 0:
3413         tty_printf(_("This key is not protected.\n"));
3414         break;
3415       case -2:
3416         tty_printf(_("Secret parts of primary key are stored on-card.\n"));
3417         ask_pass = 1;
3418         break;
3419       default:
3420         tty_printf(_("Key is protected.\n"));
3421         rc = check_secret_key( pri_sk, 0 );
3422         if( !rc )
3423             passphrase = get_last_passphrase();
3424         break;
3425     }
3426     if( rc )
3427         goto leave;
3428
3429     algo = ask_algo (1, NULL, &use);
3430     assert(algo);
3431     nbits = ask_keysize (algo, 0);
3432     expire = ask_expire_interval(timestamp,0,NULL);
3433     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
3434                                                   _("Really create? (y/N) ")))
3435         goto leave;
3436
3437     if (ask_pass)
3438         dek = do_ask_passphrase (&s2k);
3439     else if (passphrase) {
3440         s2k = xmalloc_secure( sizeof *s2k );
3441         s2k->mode = opt.s2k_mode;
3442         s2k->hash_algo = S2K_DIGEST_ALGO;
3443         set_next_passphrase( passphrase );
3444         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
3445                                  NULL, NULL );
3446     }
3447
3448     rc = do_create (algo, nbits, pub_keyblock, sec_keyblock,
3449                     dek, s2k, &sub_sk, timestamp, expire, 1 );
3450     if (!rc)
3451         rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, sub_sk,
3452                                use, timestamp);
3453     if (!rc)
3454         rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, sub_sk,
3455                                use, timestamp);
3456     if (!rc)
3457       {
3458         okay = 1;
3459         write_status_text (STATUS_KEY_CREATED, "S");
3460       }
3461
3462   leave:
3463     if( rc )
3464         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
3465     xfree( passphrase );
3466     xfree( dek );
3467     xfree( s2k );
3468     /* release the copy of the (now unprotected) secret keys */
3469     if( pri_sk )
3470         free_secret_key(pri_sk);
3471     if( sub_sk )
3472         free_secret_key(sub_sk);
3473     set_next_passphrase( NULL );
3474     return okay;
3475 }
3476
3477
3478 #ifdef ENABLE_CARD_SUPPORT
3479 /* Generate a subkey on a card. */
3480 int
3481 generate_card_subkeypair (KBNODE pub_keyblock, KBNODE sec_keyblock,
3482                           int keyno, const char *serialno)
3483 {
3484   int okay=0, rc=0;
3485   KBNODE node;
3486   PKT_secret_key *pri_sk = NULL, *sub_sk;
3487   int algo;
3488   unsigned int use;
3489   u32 timestamp,expire;
3490   char *passphrase = NULL;
3491   struct para_data_s *para = NULL;
3492
3493   assert (keyno >= 1 && keyno <= 3);
3494
3495   para = xcalloc (1, sizeof *para + strlen (serialno) );
3496   para->key = pSERIALNO;
3497   strcpy (para->u.value, serialno);
3498
3499   /* Break out the primary secret key */
3500   node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
3501   if(!node)
3502     {
3503       log_error("Oops; secret key not found anymore!\n");
3504       goto leave;
3505     }
3506
3507   /* Make a copy of the sk to keep the protected one in the keyblock */
3508   pri_sk = copy_secret_key (NULL, node->pkt->pkt.secret_key);
3509
3510   timestamp = make_timestamp();
3511   if (pri_sk->timestamp > timestamp)
3512     {
3513       ulong d = pri_sk->timestamp - timestamp;
3514       log_info (d==1 ? _("key has been created %lu second "
3515                          "in future (time warp or clock problem)\n")
3516                      : _("key has been created %lu seconds "
3517                          "in future (time warp or clock problem)\n"), d );
3518         if (!opt.ignore_time_conflict)
3519           {
3520             rc = G10ERR_TIME_CONFLICT;
3521             goto leave;
3522           }
3523     }
3524
3525   if (pri_sk->version < 4)
3526     {
3527       log_info (_("NOTE: creating subkeys for v3 keys "
3528                   "is not OpenPGP compliant\n"));
3529       goto leave;
3530     }
3531
3532   /* Unprotect to get the passphrase. */
3533   switch( is_secret_key_protected (pri_sk) )
3534     {
3535     case -1:
3536       rc = G10ERR_PUBKEY_ALGO;
3537       break;
3538     case 0:
3539       tty_printf("This key is not protected.\n");
3540       break;
3541     default:
3542       tty_printf("Key is protected.\n");
3543       rc = check_secret_key( pri_sk, 0 );
3544       if (!rc)
3545         passphrase = get_last_passphrase();
3546       break;
3547     }
3548   if (rc)
3549     goto leave;
3550
3551   algo = PUBKEY_ALGO_RSA;
3552   expire = ask_expire_interval (timestamp,0,NULL);
3553   if (keyno == 1)
3554     use = PUBKEY_USAGE_SIG;
3555   else if (keyno == 2)
3556     use = PUBKEY_USAGE_ENC;
3557   else
3558     use = PUBKEY_USAGE_AUTH;
3559   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
3560                                                _("Really create? (y/N) ")))
3561     goto leave;
3562
3563   if (passphrase)
3564     set_next_passphrase (passphrase);
3565   rc = gen_card_key (algo, keyno, 0, pub_keyblock, sec_keyblock,
3566                      &sub_sk, &timestamp, expire, para);
3567   if (!rc)
3568     rc = write_keybinding (pub_keyblock, pub_keyblock, pri_sk, sub_sk, use,
3569                            timestamp);
3570   if (!rc)
3571     rc = write_keybinding (sec_keyblock, pub_keyblock, pri_sk, sub_sk, use,
3572                            timestamp);
3573   if (!rc)
3574     {
3575       okay = 1;
3576       write_status_text (STATUS_KEY_CREATED, "S");
3577     }
3578
3579  leave:
3580   if (rc)
3581     log_error (_("Key generation failed: %s\n"), g10_errstr(rc) );
3582   xfree (passphrase);
3583   /* Release the copy of the (now unprotected) secret keys. */
3584   if (pri_sk)
3585     free_secret_key (pri_sk);
3586   set_next_passphrase( NULL );
3587   release_parameter_list (para);
3588   return okay;
3589 }
3590 #endif /* !ENABLE_CARD_SUPPORT */
3591
3592
3593 /****************
3594  * Write a keyblock to an output stream
3595  */
3596 static int
3597 write_keyblock( IOBUF out, KBNODE node )
3598 {
3599   for( ; node ; node = node->next )
3600     {
3601       if(!is_deleted_kbnode(node))
3602         {
3603           int rc = build_packet( out, node->pkt );
3604           if( rc )
3605             {
3606               log_error("build_packet(%d) failed: %s\n",
3607                         node->pkt->pkttype, g10_errstr(rc) );
3608               return G10ERR_WRITE_FILE;
3609             }
3610         }
3611     }
3612
3613   return 0;
3614 }
3615
3616
3617 /* Note that TIMESTAMP is an in/out arg. */
3618 static int
3619 gen_card_key (int algo, int keyno, int is_primary,
3620               KBNODE pub_root, KBNODE sec_root, PKT_secret_key **ret_sk,
3621               u32 *timestamp, u32 expireval, struct para_data_s *para)
3622 {
3623 #ifdef ENABLE_CARD_SUPPORT
3624   int rc;
3625   const char *s;
3626   struct agent_card_genkey_s info;
3627   PACKET *pkt;
3628   PKT_secret_key *sk;
3629   PKT_public_key *pk;
3630
3631   assert (algo == PUBKEY_ALGO_RSA);
3632
3633   /* Fixme: We don't have the serialnumber available, thus passing NULL. */
3634   rc = agent_scd_genkey (&info, keyno, 1, NULL, timestamp);
3635 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
3636 /*      { */
3637 /*        tty_printf ("\n"); */
3638 /*        log_error ("WARNING: key does already exists!\n"); */
3639 /*        tty_printf ("\n"); */
3640 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
3641 /*                                    _("Replace existing key? "))) */
3642 /*          rc = agent_scd_genkey (&info, keyno, 1); */
3643 /*      } */
3644
3645   if (rc)
3646     {
3647       log_error ("key generation failed: %s\n", gpg_strerror (rc));
3648       return rc;
3649     }
3650   if ( !info.n || !info.e )
3651     {
3652       log_error ("communication error with SCD\n");
3653       mpi_free (info.n);
3654       mpi_free (info.e);
3655       return gpg_error (GPG_ERR_GENERAL);
3656     }
3657
3658   if (*timestamp != info.created_at)
3659     log_info ("Note that the key does not use the suggested creation date\n");
3660   *timestamp = info.created_at;
3661
3662   pk = xcalloc (1, sizeof *pk );
3663   sk = xcalloc (1, sizeof *sk );
3664   sk->timestamp = pk->timestamp = info.created_at;
3665   sk->version = pk->version = 4;
3666   if (expireval)
3667       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
3668   sk->pubkey_algo = pk->pubkey_algo = algo;
3669   pk->pkey[0] = info.n;
3670   pk->pkey[1] = info.e;
3671   sk->skey[0] = mpi_copy (pk->pkey[0]);
3672   sk->skey[1] = mpi_copy (pk->pkey[1]);
3673   sk->skey[2] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
3674   sk->is_protected = 1;
3675   sk->protect.s2k.mode = 1002;
3676   s = get_parameter_value (para, pSERIALNO);
3677   if (s)
3678     {
3679       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3680            sk->protect.ivlen++, s += 2)
3681         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3682     }
3683
3684   if( ret_sk )
3685     *ret_sk = sk;
3686
3687   pkt = xcalloc (1,sizeof *pkt);
3688   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3689   pkt->pkt.public_key = pk;
3690   add_kbnode(pub_root, new_kbnode( pkt ));
3691
3692   pkt = xcalloc (1,sizeof *pkt);
3693   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3694   pkt->pkt.secret_key = sk;
3695   add_kbnode(sec_root, new_kbnode( pkt ));
3696
3697   return 0;
3698 #else
3699   return -1;
3700 #endif /*!ENABLE_CARD_SUPPORT*/
3701 }
3702
3703
3704
3705 static int
3706 gen_card_key_with_backup (int algo, int keyno, int is_primary,
3707                           KBNODE pub_root, KBNODE sec_root,
3708                           u32 timestamp,
3709                           u32 expireval, struct para_data_s *para,
3710                           const char *backup_dir)
3711 {
3712 #ifdef ENABLE_CARD_SUPPORT
3713   int rc;
3714   const char *s;
3715   PACKET *pkt;
3716   PKT_secret_key *sk, *sk_unprotected, *sk_protected;
3717   PKT_public_key *pk;
3718   size_t n;
3719   int i;
3720   unsigned int nbits;
3721
3722   sk_unprotected = NULL;
3723   sk_protected = NULL;
3724
3725   /* Get the size of the key directly from the card.  */
3726   {
3727     struct agent_card_info_s info;
3728
3729     memset (&info, 0, sizeof info);
3730     if (!agent_scd_getattr ("KEY-ATTR", &info)
3731         && info.key_attr[1].algo)
3732       nbits = info.key_attr[1].nbits;
3733     else
3734       nbits = 1024; /* All pre-v2.0 cards.  */
3735     agent_release_card_info (&info);
3736   }
3737
3738   rc = generate_raw_key (algo, nbits, timestamp,
3739                          &sk_unprotected, &sk_protected);
3740   if (rc)
3741     return rc;
3742
3743   /* First, store the key to the card. */
3744   rc = save_unprotected_key_to_card (sk_unprotected, keyno);
3745   if (rc)
3746     {
3747       log_error (_("storing key onto card failed: %s\n"), g10_errstr (rc));
3748       free_secret_key (sk_unprotected);
3749       free_secret_key (sk_protected);
3750       return rc;
3751     }
3752
3753   /* Get rid of the secret key parameters and store the serial numer. */
3754   sk = sk_unprotected;
3755   n = pubkey_get_nskey (sk->pubkey_algo);
3756   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
3757     {
3758       mpi_free (sk->skey[i]);
3759       sk->skey[i] = NULL;
3760     }
3761   i = pubkey_get_npkey (sk->pubkey_algo);
3762   sk->skey[i] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
3763   sk->is_protected = 1;
3764   sk->protect.s2k.mode = 1002;
3765   s = get_parameter_value (para, pSERIALNO);
3766   assert (s);
3767   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
3768        sk->protect.ivlen++, s += 2)
3769     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
3770
3771   /* Now write the *protected* secret key to the file.  */
3772   {
3773     char name_buffer[50];
3774     char *fname;
3775     IOBUF fp;
3776     mode_t oldmask;
3777
3778     keyid_from_sk (sk, NULL);
3779     sprintf (name_buffer,"sk_%08lX%08lX.gpg",
3780              (ulong)sk->keyid[0], (ulong)sk->keyid[1]);
3781
3782     fname = make_filename (backup_dir, name_buffer, NULL);
3783     oldmask = umask (077);
3784     if (is_secured_filename (fname))
3785       {
3786         fp = NULL;
3787         errno = EPERM;
3788       }
3789     else
3790       fp = iobuf_create (fname);
3791     umask (oldmask);
3792     if (!fp)
3793       {
3794         log_error (_("can't create backup file `%s': %s\n"),
3795                    fname, strerror(errno) );
3796         xfree (fname);
3797         free_secret_key (sk_unprotected);
3798         free_secret_key (sk_protected);
3799         return G10ERR_OPEN_FILE;
3800       }
3801
3802     pkt = xcalloc (1, sizeof *pkt);
3803     pkt->pkttype = PKT_SECRET_KEY;
3804     pkt->pkt.secret_key = sk_protected;
3805     sk_protected = NULL;
3806
3807     rc = build_packet (fp, pkt);
3808     if (rc)
3809       {
3810         log_error("build packet failed: %s\n", g10_errstr(rc) );
3811         iobuf_cancel (fp);
3812       }
3813     else
3814       {
3815         byte array[MAX_FINGERPRINT_LEN];
3816         char *fprbuf, *p;
3817
3818         iobuf_close (fp);
3819         iobuf_ioctl (NULL, 2, 0, (char*)fname);
3820         log_info (_("NOTE: backup of card key saved to `%s'\n"), fname);
3821
3822         fingerprint_from_sk (sk, array, &n);
3823         p = fprbuf = xmalloc (MAX_FINGERPRINT_LEN*2 + 1 + 1);
3824         for (i=0; i < n ; i++, p += 2)
3825           sprintf (p, "%02X", array[i]);
3826         *p++ = ' ';
3827         *p = 0;
3828
3829         write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED,
3830                                       fprbuf,
3831                                       fname, strlen (fname),
3832                                       0);
3833         xfree (fprbuf);
3834       }
3835     free_packet (pkt);
3836     xfree (pkt);
3837     xfree (fname);
3838     if (rc)
3839       {
3840         free_secret_key (sk_unprotected);
3841         return rc;
3842       }
3843   }
3844
3845   /* Create the public key from the secret key. */
3846   pk = xcalloc (1, sizeof *pk );
3847   pk->timestamp = sk->timestamp;
3848   pk->version = sk->version;
3849   if (expireval)
3850       pk->expiredate = sk->expiredate = sk->timestamp + expireval;
3851   pk->pubkey_algo = sk->pubkey_algo;
3852   n = pubkey_get_npkey (sk->pubkey_algo);
3853   for (i=0; i < n; i++)
3854     pk->pkey[i] = mpi_copy (sk->skey[i]);
3855
3856   /* Build packets and add them to the node lists.  */
3857   pkt = xcalloc (1,sizeof *pkt);
3858   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
3859   pkt->pkt.public_key = pk;
3860   add_kbnode(pub_root, new_kbnode( pkt ));
3861
3862   pkt = xcalloc (1,sizeof *pkt);
3863   pkt->pkttype = is_primary ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
3864   pkt->pkt.secret_key = sk;
3865   add_kbnode(sec_root, new_kbnode( pkt ));
3866
3867   return 0;
3868 #else
3869   return -1;
3870 #endif /*!ENABLE_CARD_SUPPORT*/
3871 }
3872
3873
3874 #ifdef ENABLE_CARD_SUPPORT
3875 int
3876 save_unprotected_key_to_card (PKT_secret_key *sk, int keyno)
3877 {
3878   int rc;
3879   unsigned char *rsa_n = NULL;
3880   unsigned char *rsa_e = NULL;
3881   unsigned char *rsa_p = NULL;
3882   unsigned char *rsa_q = NULL;
3883   unsigned int rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
3884   unsigned char *sexp = NULL;
3885   unsigned char *p;
3886   char numbuf[55], numbuf2[50];
3887
3888   assert (is_RSA (sk->pubkey_algo));
3889   assert (!sk->is_protected);
3890
3891   /* Copy the parameters into straight buffers. */
3892   rsa_n = mpi_get_secure_buffer (sk->skey[0], &rsa_n_len, NULL);
3893   rsa_e = mpi_get_secure_buffer (sk->skey[1], &rsa_e_len, NULL);
3894   rsa_p = mpi_get_secure_buffer (sk->skey[3], &rsa_p_len, NULL);
3895   rsa_q = mpi_get_secure_buffer (sk->skey[4], &rsa_q_len, NULL);
3896   if (!rsa_n || !rsa_e || !rsa_p || !rsa_q)
3897     {
3898       rc = G10ERR_INV_ARG;
3899       goto leave;
3900     }
3901
3902   /* Put the key into an S-expression. */
3903   sexp = p = xmalloc_secure (30
3904                              + rsa_n_len + rsa_e_len + rsa_p_len + rsa_q_len
3905                              + 4*sizeof (numbuf) + 25 + sizeof(numbuf) + 20);
3906
3907   p = stpcpy (p,"(11:private-key(3:rsa(1:n");
3908   sprintf (numbuf, "%u:", rsa_n_len);
3909   p = stpcpy (p, numbuf);
3910   memcpy (p, rsa_n, rsa_n_len);
3911   p += rsa_n_len;
3912
3913   sprintf (numbuf, ")(1:e%u:", rsa_e_len);
3914   p = stpcpy (p, numbuf);
3915   memcpy (p, rsa_e, rsa_e_len);
3916   p += rsa_e_len;
3917
3918   sprintf (numbuf, ")(1:p%u:", rsa_p_len);
3919   p = stpcpy (p, numbuf);
3920   memcpy (p, rsa_p, rsa_p_len);
3921   p += rsa_p_len;
3922
3923   sprintf (numbuf, ")(1:q%u:", rsa_q_len);
3924   p = stpcpy (p, numbuf);
3925   memcpy (p, rsa_q, rsa_q_len);
3926   p += rsa_q_len;
3927
3928   p = stpcpy (p,"))(10:created-at");
3929   sprintf (numbuf2, "%lu", (unsigned long)sk->timestamp);
3930   sprintf (numbuf, "%lu:", (unsigned long)strlen (numbuf2));
3931   p = stpcpy (stpcpy (stpcpy (p, numbuf), numbuf2), "))");
3932
3933   /* Fixme: Unfortunately we don't have the serialnumber available -
3934      thus we can't pass it down to the agent. */
3935   rc = agent_scd_writekey (keyno, NULL, sexp, p - sexp);
3936
3937  leave:
3938   xfree (sexp);
3939   xfree (rsa_n);
3940   xfree (rsa_e);
3941   xfree (rsa_p);
3942   xfree (rsa_q);
3943   return rc;
3944 }
3945 #endif /*ENABLE_CARD_SUPPORT*/