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