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