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