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