* cardglue.c (pin_cb): Detect whether an admin or regular PIN is
[gnupg.git] / g10 / keygen.c
1 /* keygen.c - generate a key pair
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *                                               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 2 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, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <errno.h>
28 #include <assert.h>
29 #include "util.h"
30 #include "main.h"
31 #include "packet.h"
32 #include "cipher.h"
33 #include "ttyio.h"
34 #include "options.h"
35 #include "keydb.h"
36 #include "trustdb.h"
37 #include "status.h"
38 #include "i18n.h"
39 #include "cardglue.h"
40
41 #define MAX_PREFS 30 
42
43 enum para_name {
44   pKEYTYPE,
45   pKEYLENGTH,
46   pKEYUSAGE,
47   pSUBKEYTYPE,
48   pSUBKEYLENGTH,
49   pSUBKEYUSAGE,
50   pAUTHKEYTYPE,
51   pNAMEREAL,
52   pNAMEEMAIL,
53   pNAMECOMMENT,
54   pPREFERENCES,
55   pREVOKER,
56   pUSERID,
57   pEXPIREDATE,
58   pKEYEXPIRE, /* in n seconds */
59   pSUBKEYEXPIRE, /* in n seconds */
60   pPASSPHRASE,
61   pPASSPHRASE_DEK,
62   pPASSPHRASE_S2K,
63   pSERIALNO
64 };
65
66 struct para_data_s {
67     struct para_data_s *next;
68     int lnr;
69     enum para_name key;
70     union {
71         DEK *dek;
72         STRING2KEY *s2k;
73         u32 expire;
74         unsigned int usage;
75         struct revocation_key revkey;
76         char value[1];
77     } u;
78 };
79
80 struct output_control_s {
81     int lnr;
82     int dryrun;
83     int use_files;
84     struct {
85         char  *fname;
86         char  *newfname;
87         IOBUF stream;
88         armor_filter_context_t afx;
89     } pub;
90     struct {
91         char  *fname;
92         char  *newfname;
93         IOBUF stream;
94         armor_filter_context_t afx;
95     } sec;
96 };
97
98
99 struct opaque_data_usage_and_pk {
100     unsigned int usage;
101     PKT_public_key *pk;
102 };
103
104
105 static int prefs_initialized = 0;
106 static byte sym_prefs[MAX_PREFS];
107 static int nsym_prefs;
108 static byte hash_prefs[MAX_PREFS];
109 static int nhash_prefs;
110 static byte zip_prefs[MAX_PREFS];
111 static int nzip_prefs;
112 static int mdc_available,ks_modify;
113
114 static void do_generate_keypair( struct para_data_s *para,
115                                  struct output_control_s *outctrl, int card );
116 static int  write_keyblock( IOBUF out, KBNODE node );
117 #ifdef ENABLE_CARD_SUPPORT
118 static int gen_card_key (int algo, int keyno, KBNODE pub_root, KBNODE sec_root,
119                          u32 expireval, struct para_data_s *para);
120 #endif
121
122 static void
123 write_uid( KBNODE root, const char *s )
124 {
125     PACKET *pkt = m_alloc_clear(sizeof *pkt );
126     size_t n = strlen(s);
127
128     pkt->pkttype = PKT_USER_ID;
129     pkt->pkt.user_id = m_alloc_clear( sizeof *pkt->pkt.user_id + n - 1 );
130     pkt->pkt.user_id->len = n;
131     pkt->pkt.user_id->ref = 1;
132     strcpy(pkt->pkt.user_id->name, s);
133     add_kbnode( root, new_kbnode( pkt ) );
134 }
135
136 static void
137 do_add_key_flags (PKT_signature *sig, unsigned int use)
138 {
139     byte buf[1];
140
141     if (!use) 
142         return;
143
144     buf[0] = 0;
145     if (use & PUBKEY_USAGE_SIG)
146       {
147         if(sig->sig_class==0x18)
148           buf[0] |= 0x02; /* Don't set the certify flag for subkeys */
149         else
150           buf[0] |= 0x01 | 0x02;
151       }
152     if (use & PUBKEY_USAGE_ENC)
153         buf[0] |= 0x04 | 0x08;
154     if (use & PUBKEY_USAGE_AUTH)
155         buf[0] |= 0x20;
156     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, 1);
157 }
158
159
160 int
161 keygen_add_key_expire( PKT_signature *sig, void *opaque )
162 {
163     PKT_public_key *pk = opaque;
164     byte buf[8];
165     u32  u;
166
167     if( pk->expiredate ) {
168         if(pk->expiredate > pk->timestamp)
169           u= pk->expiredate - pk->timestamp;
170         else
171           u= 0;
172
173         buf[0] = (u >> 24) & 0xff;
174         buf[1] = (u >> 16) & 0xff;
175         buf[2] = (u >>  8) & 0xff;
176         buf[3] = u & 0xff;
177         build_sig_subpkt( sig, SIGSUBPKT_KEY_EXPIRE, buf, 4 );
178     }
179     else
180       {
181         /* Make sure we don't leave a key expiration subpacket lying
182            around */
183         delete_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE);
184       }
185
186     return 0;
187 }
188
189 static int
190 keygen_add_key_flags_and_expire (PKT_signature *sig, void *opaque)
191 {
192     struct opaque_data_usage_and_pk *oduap = opaque;
193
194     do_add_key_flags (sig, oduap->usage);
195     return keygen_add_key_expire (sig, oduap->pk);
196 }
197
198 static int
199 set_one_pref (int val, int type, const char *item, byte *buf, int *nbuf)
200 {
201     int i;
202
203     for (i=0; i < *nbuf; i++ )
204       if (buf[i] == val)
205         {
206           log_info (_("preference `%s' duplicated\n"), item);
207           return -1;
208         }
209
210     if (*nbuf >= MAX_PREFS)
211       {
212         if(type==1)
213           log_info(_("too many cipher preferences\n"));
214         else if(type==2)
215           log_info(_("too many digest preferences\n"));
216         else if(type==3)
217           log_info(_("too many compression preferences\n"));
218         else
219           BUG();
220
221         return -1;
222       }
223
224     buf[(*nbuf)++] = val;
225     return 0;
226 }
227
228 #ifdef USE_AES
229 #define AES "S9 S8 S7 "
230 #else
231 #define AES ""
232 #endif
233
234 #ifdef USE_CAST5
235 #define CAST5 "S3 "
236 #else
237 #define CAST5 ""
238 #endif
239
240 /*
241  * Parse the supplied string and use it to set the standard
242  * preferences.  The string may be in a form like the one printed by
243  * "pref" (something like: "S10 S3 H3 H2 Z2 Z1") or the actual
244  * cipher/hash/compress names.  Use NULL to set the default
245  * preferences.  Returns: 0 = okay
246  */
247 int
248 keygen_set_std_prefs (const char *string,int personal)
249 {
250     byte sym[MAX_PREFS], hash[MAX_PREFS], zip[MAX_PREFS];
251     int nsym=0, nhash=0, nzip=0, val, rc=0;
252     int mdc=1, modify=0; /* mdc defaults on, modify defaults off. */
253
254     if (!string || !ascii_strcasecmp (string, "default")) {
255       if (opt.def_preference_list)
256         string=opt.def_preference_list;
257       else if ( !check_cipher_algo(CIPHER_ALGO_IDEA) )
258         string = AES CAST5 "S2 S1 H2 H3 Z2 Z1";
259       else
260         string = AES CAST5 "S2 H2 H3 Z2 Z1";
261
262       /* If we have it, IDEA goes *after* 3DES so it won't be used
263          unless we're encrypting along with a V3 key.  Ideally, we
264          would only put the S1 preference in if the key was RSA and
265          <=2048 bits, as that is what won't break PGP2, but that is
266          difficult with the current code, and not really worth
267          checking as a non-RSA <=2048 bit key wouldn't be usable by
268          PGP2 anyway. -dms */
269     }
270     else if (!ascii_strcasecmp (string, "none"))
271         string = "";
272
273     if(strlen(string))
274       {
275         char *tok,*prefstring;
276
277         prefstring=m_strdup(string); /* need a writable string! */
278
279         while((tok=strsep(&prefstring," ,")))
280           {
281             if((val=string_to_cipher_algo(tok)))
282               {
283                 if(set_one_pref(val,1,tok,sym,&nsym))
284                   rc=-1;
285               }
286             else if((val=string_to_digest_algo(tok)))
287               {
288                 if(set_one_pref(val,2,tok,hash,&nhash))
289                   rc=-1;
290               }
291             else if((val=string_to_compress_algo(tok))>-1)
292               {
293                 if(set_one_pref(val,3,tok,zip,&nzip))
294                   rc=-1;
295               }
296             else if (ascii_strcasecmp(tok,"mdc")==0)
297               mdc=1;
298             else if (ascii_strcasecmp(tok,"no-mdc")==0)
299               mdc=0;
300             else if (ascii_strcasecmp(tok,"ks-modify")==0)
301               modify=1;
302             else if (ascii_strcasecmp(tok,"no-ks-modify")==0)
303               modify=0;
304             else
305               {
306                 log_info (_("invalid item `%s' in preference string\n"),tok);
307
308                 /* Complain if IDEA is not available. */
309                 if(ascii_strcasecmp(tok,"s1")==0
310                    || ascii_strcasecmp(tok,"idea")==0)
311                   idea_cipher_warn(1);
312
313                 rc=-1;
314               }
315           }
316
317         m_free(prefstring);
318       }
319
320     if(!rc)
321       {
322         if(personal)
323           {
324             if(personal==PREFTYPE_SYM)
325               {
326                 m_free(opt.personal_cipher_prefs);
327
328                 if(nsym==0)
329                   opt.personal_cipher_prefs=NULL;
330                 else
331                   {
332                     int i;
333
334                     opt.personal_cipher_prefs=
335                       m_alloc(sizeof(prefitem_t *)*(nsym+1));
336
337                     for (i=0; i<nsym; i++)
338                       {
339                         opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
340                         opt.personal_cipher_prefs[i].value = sym[i];
341                       }
342
343                     opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
344                     opt.personal_cipher_prefs[i].value = 0;
345                   }
346               }
347             else if(personal==PREFTYPE_HASH)
348               {
349                 m_free(opt.personal_digest_prefs);
350
351                 if(nhash==0)
352                   opt.personal_digest_prefs=NULL;
353                 else
354                   {
355                     int i;
356
357                     opt.personal_digest_prefs=
358                       m_alloc(sizeof(prefitem_t *)*(nhash+1));
359
360                     for (i=0; i<nhash; i++)
361                       {
362                         opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
363                         opt.personal_digest_prefs[i].value = hash[i];
364                       }
365
366                     opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
367                     opt.personal_digest_prefs[i].value = 0;
368                   }
369               }
370             else if(personal==PREFTYPE_ZIP)
371               {
372                 m_free(opt.personal_compress_prefs);
373
374                 if(nzip==0)
375                   opt.personal_compress_prefs=NULL;
376                 else
377                   {
378                     int i;
379
380                     opt.personal_compress_prefs=
381                       m_alloc(sizeof(prefitem_t *)*(nzip+1));
382
383                     for (i=0; i<nzip; i++)
384                       {
385                         opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
386                         opt.personal_compress_prefs[i].value = zip[i];
387                       }
388
389                     opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
390                     opt.personal_compress_prefs[i].value = 0;
391                   }
392               }
393           }
394         else
395           {
396             memcpy (sym_prefs,  sym,  (nsym_prefs=nsym));
397             memcpy (hash_prefs, hash, (nhash_prefs=nhash));
398             memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
399             mdc_available = mdc;
400             ks_modify = modify;
401             prefs_initialized = 1;
402           }
403       }
404
405     return rc;
406 }
407
408 #undef CAST5
409 #undef AES
410
411 /* Return a fake user ID containing the preferences.  Caller must
412    free. */
413 PKT_user_id *keygen_get_std_prefs(void)
414 {
415   int i,j=0;
416   PKT_user_id *uid=m_alloc_clear(sizeof(PKT_user_id));
417
418   if(!prefs_initialized)
419     keygen_set_std_prefs(NULL,0);
420
421   uid->prefs=m_alloc((sizeof(prefitem_t *)*
422                       (nsym_prefs+nhash_prefs+nzip_prefs+1)));
423
424   for(i=0;i<nsym_prefs;i++,j++)
425     {
426       uid->prefs[j].type=PREFTYPE_SYM;
427       uid->prefs[j].value=sym_prefs[i];
428     }
429
430   for(i=0;i<nhash_prefs;i++,j++)
431     {
432       uid->prefs[j].type=PREFTYPE_HASH;
433       uid->prefs[j].value=hash_prefs[i];
434     }
435
436   for(i=0;i<nzip_prefs;i++,j++)
437     {
438       uid->prefs[j].type=PREFTYPE_ZIP;
439       uid->prefs[j].value=zip_prefs[i];
440     }
441
442   uid->prefs[j].type=PREFTYPE_NONE;
443   uid->prefs[j].value=0;
444
445   uid->mdc_feature=mdc_available;
446   uid->ks_modify=ks_modify;
447
448   return uid;
449 }
450
451 static void
452 add_feature_mdc (PKT_signature *sig,int enabled)
453 {
454     const byte *s;
455     size_t n;
456     int i;
457     char *buf;
458
459     s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n );
460     /* Already set or cleared */
461     if (s && n &&
462         ((enabled && (s[0] & 0x01)) || (!enabled && !(s[0] & 0x01))))
463       return;
464
465     if (!s || !n) { /* create a new one */
466         n = 1;
467         buf = m_alloc_clear (n);
468     }
469     else {
470         buf = m_alloc (n);
471         memcpy (buf, s, n);
472     }
473
474     if(enabled)
475       buf[0] |= 0x01; /* MDC feature */
476     else
477       buf[0] &= ~0x01;
478
479     /* Are there any bits set? */
480     for(i=0;i<n;i++)
481       if(buf[i]!=0)
482         break;
483
484     if(i==n)
485       delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
486     else
487       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
488
489     m_free (buf);
490 }
491
492 static void
493 add_keyserver_modify (PKT_signature *sig,int enabled)
494 {
495   const byte *s;
496   size_t n;
497   int i;
498   char *buf;
499
500   /* The keyserver modify flag is a negative flag (i.e. no-modify) */
501   enabled=!enabled;
502
503   s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n );
504   /* Already set or cleared */
505   if (s && n &&
506       ((enabled && (s[0] & 0x80)) || (!enabled && !(s[0] & 0x80))))
507     return;
508
509   if (!s || !n) { /* create a new one */
510     n = 1;
511     buf = m_alloc_clear (n);
512   }
513   else {
514     buf = m_alloc (n);
515     memcpy (buf, s, n);
516   }
517
518   if(enabled)
519     buf[0] |= 0x80; /* no-modify flag */
520   else
521     buf[0] &= ~0x80;
522
523   /* Are there any bits set? */
524   for(i=0;i<n;i++)
525     if(buf[i]!=0)
526       break;
527
528   if(i==n)
529     delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
530   else
531     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
532
533   m_free (buf);
534 }
535
536 int
537 keygen_upd_std_prefs( PKT_signature *sig, void *opaque )
538 {
539     if (!prefs_initialized)
540         keygen_set_std_prefs (NULL, 0);
541
542     if (nsym_prefs) 
543         build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
544     else
545       {
546         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
547         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
548       }
549
550     if (nhash_prefs)
551         build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
552     else
553       {
554         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
555         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
556       }
557
558     if (nzip_prefs)
559         build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
560     else
561       {
562         delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
563         delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
564       }
565
566     /* Make sure that the MDC feature flag is set if needed */
567     add_feature_mdc (sig,mdc_available);
568     add_keyserver_modify (sig,ks_modify);
569
570     return 0;
571 }
572
573
574 /****************
575  * Add preference to the self signature packet.
576  * This is only called for packets with version > 3.
577
578  */
579 int
580 keygen_add_std_prefs( PKT_signature *sig, void *opaque )
581 {
582     PKT_public_key *pk = opaque;
583
584     do_add_key_flags (sig, pk->pubkey_usage);
585     keygen_add_key_expire( sig, opaque );
586     keygen_upd_std_prefs (sig, opaque);
587
588     return 0;
589 }
590
591 int
592 keygen_add_keyserver_url(PKT_signature *sig, void *opaque)
593 {
594   const char *url=opaque;
595
596   build_sig_subpkt(sig,SIGSUBPKT_PREF_KS,url,strlen(url));
597
598   return 0;
599 }
600
601 int
602 keygen_add_revkey(PKT_signature *sig, void *opaque)
603 {
604   struct revocation_key *revkey=opaque;
605   byte buf[2+MAX_FINGERPRINT_LEN];
606
607   buf[0]=revkey->class;
608   buf[1]=revkey->algid;
609   memcpy(&buf[2],revkey->fpr,MAX_FINGERPRINT_LEN);
610
611   build_sig_subpkt(sig,SIGSUBPKT_REV_KEY,buf,2+MAX_FINGERPRINT_LEN);
612
613   /* All sigs with revocation keys set are nonrevocable */
614   sig->flags.revocable=0;
615   buf[0] = 0;
616   build_sig_subpkt( sig, SIGSUBPKT_REVOCABLE, buf, 1 );
617
618   parse_revkeys(sig);
619
620   return 0;
621 }
622
623 static int
624 write_direct_sig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
625                   struct revocation_key *revkey )
626 {
627     PACKET *pkt;
628     PKT_signature *sig;
629     int rc=0;
630     KBNODE node;
631     PKT_public_key *pk;
632
633     if( opt.verbose )
634         log_info(_("writing direct signature\n"));
635
636     /* get the pk packet from the pub_tree */
637     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
638     if( !node )
639         BUG();
640     pk = node->pkt->pkt.public_key;
641
642     /* we have to cache the key, so that the verification of the signature
643      * creation is able to retrieve the public key */
644     cache_public_key (pk);
645
646     /* and make the signature */
647     rc = make_keysig_packet(&sig,pk,NULL,NULL,sk,0x1F,0,0,0,0,
648                             keygen_add_revkey,revkey);
649     if( rc ) {
650         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
651         return rc;
652     }
653
654     pkt = m_alloc_clear( sizeof *pkt );
655     pkt->pkttype = PKT_SIGNATURE;
656     pkt->pkt.signature = sig;
657     add_kbnode( root, new_kbnode( pkt ) );
658     return rc;
659 }
660
661 static int
662 write_selfsig( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
663                unsigned int use )
664 {
665     PACKET *pkt;
666     PKT_signature *sig;
667     PKT_user_id *uid;
668     int rc=0;
669     KBNODE node;
670     PKT_public_key *pk;
671
672     if( opt.verbose )
673         log_info(_("writing self signature\n"));
674
675     /* get the uid packet from the list */
676     node = find_kbnode( root, PKT_USER_ID );
677     if( !node )
678         BUG(); /* no user id packet in tree */
679     uid = node->pkt->pkt.user_id;
680     /* get the pk packet from the pub_tree */
681     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
682     if( !node )
683         BUG();
684     pk = node->pkt->pkt.public_key;
685     pk->pubkey_usage = use;
686     /* we have to cache the key, so that the verification of the signature
687      * creation is able to retrieve the public key */
688     cache_public_key (pk);
689
690     /* and make the signature */
691     rc = make_keysig_packet( &sig, pk, uid, NULL, sk, 0x13, 0, 0, 0, 0,
692                              keygen_add_std_prefs, pk );
693     if( rc ) {
694         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
695         return rc;
696     }
697
698     pkt = m_alloc_clear( sizeof *pkt );
699     pkt->pkttype = PKT_SIGNATURE;
700     pkt->pkt.signature = sig;
701     add_kbnode( root, new_kbnode( pkt ) );
702     return rc;
703 }
704
705 static int
706 write_keybinding( KBNODE root, KBNODE pub_root, PKT_secret_key *sk,
707                   unsigned int use )
708 {
709     PACKET *pkt;
710     PKT_signature *sig;
711     int rc=0;
712     KBNODE node;
713     PKT_public_key *pk, *subpk;
714     struct opaque_data_usage_and_pk oduap;
715
716     if( opt.verbose )
717         log_info(_("writing key binding signature\n"));
718
719     /* get the pk packet from the pub_tree */
720     node = find_kbnode( pub_root, PKT_PUBLIC_KEY );
721     if( !node )
722         BUG();
723     pk = node->pkt->pkt.public_key;
724     /* we have to cache the key, so that the verification of the signature
725      * creation is able to retrieve the public key */
726     cache_public_key (pk);
727  
728     /* find the last subkey */
729     subpk = NULL;
730     for(node=pub_root; node; node = node->next ) {
731         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
732             subpk = node->pkt->pkt.public_key;
733     }
734     if( !subpk )
735         BUG();
736
737     /* and make the signature */
738     oduap.usage = use;
739     oduap.pk = subpk;
740     rc = make_keysig_packet( &sig, pk, NULL, subpk, sk, 0x18, 0, 0, 0, 0,
741                              keygen_add_key_flags_and_expire, &oduap );
742     if( rc ) {
743         log_error("make_keysig_packet failed: %s\n", g10_errstr(rc) );
744         return rc;
745     }
746
747     pkt = m_alloc_clear( sizeof *pkt );
748     pkt->pkttype = PKT_SIGNATURE;
749     pkt->pkt.signature = sig;
750     add_kbnode( root, new_kbnode( pkt ) );
751     return rc;
752 }
753
754
755 static int
756 gen_elg(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
757         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
758 {
759     int rc;
760     int i;
761     PACKET *pkt;
762     PKT_secret_key *sk;
763     PKT_public_key *pk;
764     MPI skey[4];
765     MPI *factors;
766
767     assert( is_ELGAMAL(algo) );
768
769     if( nbits < 512 ) {
770         nbits = 1024;
771         log_info(_("keysize invalid; using %u bits\n"), nbits );
772     }
773
774     if( (nbits % 32) ) {
775         nbits = ((nbits + 31) / 32) * 32;
776         log_info(_("keysize rounded up to %u bits\n"), nbits );
777     }
778
779     rc = pubkey_generate( algo, nbits, skey, &factors );
780     if( rc ) {
781         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
782         return rc;
783     }
784
785     sk = m_alloc_clear( sizeof *sk );
786     pk = m_alloc_clear( sizeof *pk );
787     sk->timestamp = pk->timestamp = make_timestamp();
788     sk->version = pk->version = 4;
789     if( expireval ) {
790         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
791     }
792     sk->pubkey_algo = pk->pubkey_algo = algo;
793                        pk->pkey[0] = mpi_copy( skey[0] );
794                        pk->pkey[1] = mpi_copy( skey[1] );
795                        pk->pkey[2] = mpi_copy( skey[2] );
796     sk->skey[0] = skey[0];
797     sk->skey[1] = skey[1];
798     sk->skey[2] = skey[2];
799     sk->skey[3] = skey[3];
800     sk->is_protected = 0;
801     sk->protect.algo = 0;
802
803     sk->csum = checksum_mpi( sk->skey[3] );
804     if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
805         *ret_sk = copy_secret_key( NULL, sk );
806
807     if( dek ) {
808         sk->protect.algo = dek->algo;
809         sk->protect.s2k = *s2k;
810         rc = protect_secret_key( sk, dek );
811         if( rc ) {
812             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
813             free_public_key(pk);
814             free_secret_key(sk);
815             return rc;
816         }
817     }
818
819     pkt = m_alloc_clear(sizeof *pkt);
820     pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
821     pkt->pkt.public_key = pk;
822     add_kbnode(pub_root, new_kbnode( pkt ));
823
824     /* don't know whether it makes sense to have the factors, so for now
825      * we store them in the secret keyring (but they are not secret) */
826     pkt = m_alloc_clear(sizeof *pkt);
827     pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
828     pkt->pkt.secret_key = sk;
829     add_kbnode(sec_root, new_kbnode( pkt ));
830     for(i=0; factors[i]; i++ )
831         add_kbnode( sec_root,
832                     make_mpi_comment_node("#:ELG_factor:", factors[i] ));
833
834     return 0;
835 }
836
837
838 /****************
839  * Generate a DSA key
840  */
841 static int
842 gen_dsa(unsigned int nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
843             STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
844 {
845     int rc;
846     int i;
847     PACKET *pkt;
848     PKT_secret_key *sk;
849     PKT_public_key *pk;
850     MPI skey[5];
851     MPI *factors;
852
853     if( nbits > 1024 || nbits < 512 ) {
854         nbits = 1024;
855         log_info(_("keysize invalid; using %u bits\n"), nbits );
856     }
857
858     if( (nbits % 64) ) {
859         nbits = ((nbits + 63) / 64) * 64;
860         log_info(_("keysize rounded up to %u bits\n"), nbits );
861     }
862
863     rc = pubkey_generate( PUBKEY_ALGO_DSA, nbits, skey, &factors );
864     if( rc ) {
865         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
866         return rc;
867     }
868
869     sk = m_alloc_clear( sizeof *sk );
870     pk = m_alloc_clear( sizeof *pk );
871     sk->timestamp = pk->timestamp = make_timestamp();
872     sk->version = pk->version = 4;
873     if( expireval ) {
874         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
875     }
876     sk->pubkey_algo = pk->pubkey_algo = PUBKEY_ALGO_DSA;
877                        pk->pkey[0] = mpi_copy( skey[0] );
878                        pk->pkey[1] = mpi_copy( skey[1] );
879                        pk->pkey[2] = mpi_copy( skey[2] );
880                        pk->pkey[3] = mpi_copy( skey[3] );
881     sk->skey[0] = skey[0];
882     sk->skey[1] = skey[1];
883     sk->skey[2] = skey[2];
884     sk->skey[3] = skey[3];
885     sk->skey[4] = skey[4];
886     sk->is_protected = 0;
887     sk->protect.algo = 0;
888
889     sk->csum = checksum_mpi ( sk->skey[4] );
890     if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
891         *ret_sk = copy_secret_key( NULL, sk );
892
893     if( dek ) {
894         sk->protect.algo = dek->algo;
895         sk->protect.s2k = *s2k;
896         rc = protect_secret_key( sk, dek );
897         if( rc ) {
898             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
899             free_public_key(pk);
900             free_secret_key(sk);
901             return rc;
902         }
903     }
904
905     pkt = m_alloc_clear(sizeof *pkt);
906     pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
907     pkt->pkt.public_key = pk;
908     add_kbnode(pub_root, new_kbnode( pkt ));
909
910     /* don't know whether it makes sense to have the factors, so for now
911      * we store them in the secret keyring (but they are not secret)
912      * p = 2 * q * f1 * f2 * ... * fn
913      * We store only f1 to f_n-1;  fn can be calculated because p and q
914      * are known.
915      */
916     pkt = m_alloc_clear(sizeof *pkt);
917     pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
918     pkt->pkt.secret_key = sk;
919     add_kbnode(sec_root, new_kbnode( pkt ));
920     for(i=1; factors[i]; i++ )  /* the first one is q */
921         add_kbnode( sec_root,
922                     make_mpi_comment_node("#:DSA_factor:", factors[i] ));
923
924     return 0;
925 }
926
927
928 /* 
929  * Generate an RSA key.
930  */
931 static int
932 gen_rsa(int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root, DEK *dek,
933         STRING2KEY *s2k, PKT_secret_key **ret_sk, u32 expireval )
934 {
935     int rc;
936     PACKET *pkt;
937     PKT_secret_key *sk;
938     PKT_public_key *pk;
939     MPI skey[6];
940     MPI *factors;
941
942     assert( is_RSA(algo) );
943
944     if( nbits < 1024 ) {
945         nbits = 1024;
946         log_info(_("keysize invalid; using %u bits\n"), nbits );
947     }
948
949     if( (nbits % 32) ) {
950         nbits = ((nbits + 31) / 32) * 32;
951         log_info(_("keysize rounded up to %u bits\n"), nbits );
952     }
953
954     rc = pubkey_generate( algo, nbits, skey, &factors );
955     if( rc ) {
956         log_error("pubkey_generate failed: %s\n", g10_errstr(rc) );
957         return rc;
958     }
959
960     sk = m_alloc_clear( sizeof *sk );
961     pk = m_alloc_clear( sizeof *pk );
962     sk->timestamp = pk->timestamp = make_timestamp();
963     sk->version = pk->version = 4;
964     if( expireval ) {
965         sk->expiredate = pk->expiredate = sk->timestamp + expireval;
966     }
967     sk->pubkey_algo = pk->pubkey_algo = algo;
968                        pk->pkey[0] = mpi_copy( skey[0] );
969                        pk->pkey[1] = mpi_copy( skey[1] );
970     sk->skey[0] = skey[0];
971     sk->skey[1] = skey[1];
972     sk->skey[2] = skey[2];
973     sk->skey[3] = skey[3];
974     sk->skey[4] = skey[4];
975     sk->skey[5] = skey[5];
976     sk->is_protected = 0;
977     sk->protect.algo = 0;
978
979     sk->csum  = checksum_mpi (sk->skey[2] );
980     sk->csum += checksum_mpi (sk->skey[3] );
981     sk->csum += checksum_mpi (sk->skey[4] );
982     sk->csum += checksum_mpi (sk->skey[5] );
983     if( ret_sk ) /* not a subkey: return an unprotected version of the sk */
984         *ret_sk = copy_secret_key( NULL, sk );
985
986     if( dek ) {
987         sk->protect.algo = dek->algo;
988         sk->protect.s2k = *s2k;
989         rc = protect_secret_key( sk, dek );
990         if( rc ) {
991             log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
992             free_public_key(pk);
993             free_secret_key(sk);
994             return rc;
995         }
996     }
997
998     pkt = m_alloc_clear(sizeof *pkt);
999     pkt->pkttype = ret_sk ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
1000     pkt->pkt.public_key = pk;
1001     add_kbnode(pub_root, new_kbnode( pkt ));
1002
1003     pkt = m_alloc_clear(sizeof *pkt);
1004     pkt->pkttype = ret_sk ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
1005     pkt->pkt.secret_key = sk;
1006     add_kbnode(sec_root, new_kbnode( pkt ));
1007
1008     return 0;
1009 }
1010
1011
1012 /****************
1013  * check valid days:
1014  * return 0 on error or the multiplier
1015  */
1016 static int
1017 check_valid_days( const char *s )
1018 {
1019     if( !digitp(s) )
1020         return 0;
1021     for( s++; *s; s++)
1022         if( !digitp(s) )
1023             break;
1024     if( !*s )
1025         return 1;
1026     if( s[1] )
1027         return 0; /* e.g. "2323wc" */
1028     if( *s == 'd' || *s == 'D' )
1029         return 1;
1030     if( *s == 'w' || *s == 'W' )
1031         return 7;
1032     if( *s == 'm' || *s == 'M' )
1033         return 30;
1034     if( *s == 'y' || *s == 'Y' )
1035         return 365;
1036     return 0;
1037 }
1038
1039
1040 /****************
1041  * Returns: 0 to create both a DSA and a ElGamal key.
1042  *          and only if key flags are to be written the desired usage.
1043  */
1044 static int
1045 ask_algo (int addmode, unsigned int *r_usage)
1046 {
1047     char *answer;
1048     int algo;
1049
1050     *r_usage = 0;
1051     tty_printf(_("Please select what kind of key you want:\n"));
1052     if( !addmode )
1053         tty_printf(_("   (%d) DSA and ElGamal (default)\n"), 1 );
1054     tty_printf(    _("   (%d) DSA (sign only)\n"), 2 );
1055     if( addmode )
1056         tty_printf(    _("   (%d) ElGamal (encrypt only)\n"), 3 );
1057     if (opt.expert)
1058         tty_printf(    _("   (%d) ElGamal (sign and encrypt)\n"), 4 );
1059     tty_printf(    _("   (%d) RSA (sign only)\n"), 5 );
1060     if (addmode)
1061         tty_printf(    _("   (%d) RSA (encrypt only)\n"), 6 );
1062     if (opt.expert)
1063       tty_printf(    _("   (%d) RSA (sign and encrypt)\n"), 7 );
1064
1065     for(;;) {
1066         answer = cpr_get("keygen.algo",_("Your selection? "));
1067         cpr_kill_prompt();
1068         algo = *answer? atoi(answer): 1;
1069         m_free(answer);
1070         if( algo == 1 && !addmode ) {
1071             algo = 0;   /* create both keys */
1072             break;
1073         }
1074         else if( algo == 7 && opt.expert ) {
1075             algo = PUBKEY_ALGO_RSA;
1076             *r_usage = PUBKEY_USAGE_ENC | PUBKEY_USAGE_SIG;
1077             break;
1078         }
1079         else if( algo == 6 && addmode ) {
1080             algo = PUBKEY_ALGO_RSA;
1081             *r_usage = PUBKEY_USAGE_ENC;
1082             break;
1083         }
1084         else if( algo == 5 ) {
1085             algo = PUBKEY_ALGO_RSA;
1086             *r_usage = PUBKEY_USAGE_SIG;
1087             break;
1088         }
1089         else if( algo == 4 && opt.expert)
1090           {
1091             tty_printf(_(
1092 "The use of this algorithm is only supported by GnuPG.  You will not be\n"
1093 "able to use this key to communicate with PGP users.  This algorithm is also\n"
1094 "very slow, and may not be as secure as the other choices.\n"));
1095
1096             if( cpr_get_answer_is_yes("keygen.algo.elg_se",
1097                                       _("Create anyway? ")))
1098               {
1099                 algo = PUBKEY_ALGO_ELGAMAL;
1100                 *r_usage = PUBKEY_USAGE_ENC | PUBKEY_USAGE_SIG;
1101                 break;
1102               }
1103         }
1104         else if( algo == 3 && addmode ) {
1105             algo = PUBKEY_ALGO_ELGAMAL_E;
1106             *r_usage = PUBKEY_USAGE_ENC;
1107             break;
1108         }
1109         else if( algo == 2 ) {
1110             algo = PUBKEY_ALGO_DSA;
1111             *r_usage = PUBKEY_USAGE_SIG;
1112             break;
1113         }
1114         else
1115             tty_printf(_("Invalid selection.\n"));
1116     }
1117     return algo;
1118 }
1119
1120
1121 static unsigned
1122 ask_keysize( int algo )
1123 {
1124     char *answer;
1125     unsigned nbits;
1126
1127     if (algo != PUBKEY_ALGO_DSA && algo != PUBKEY_ALGO_RSA) {
1128         tty_printf (_("About to generate a new %s keypair.\n"
1129                       "              minimum keysize is  768 bits\n"
1130                       "              default keysize is 1024 bits\n"
1131                       "    highest suggested keysize is 2048 bits\n"),
1132                     pubkey_algo_to_string(algo) );
1133     }
1134
1135     for(;;) {
1136         answer = cpr_get("keygen.size",
1137                           _("What keysize do you want? (1024) "));
1138         cpr_kill_prompt();
1139         nbits = *answer? atoi(answer): 1024;
1140         m_free(answer);
1141         if( algo == PUBKEY_ALGO_DSA && (nbits < 512 || nbits > 1024) )
1142             tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
1143         else if( algo == PUBKEY_ALGO_RSA && nbits < 1024 )
1144             tty_printf(_("keysize too small;"
1145                          " 1024 is smallest value allowed for RSA.\n"));
1146         else if( nbits < 768 )
1147             tty_printf(_("keysize too small;"
1148                          " 768 is smallest value allowed.\n"));
1149         else if( nbits > 4096 ) {
1150             /* It is ridiculous and an annoyance to use larger key sizes!
1151              * GnuPG can handle much larger sizes; but it takes an eternity
1152              * to create such a key (but less than the time the Sirius
1153              * Computer Corporation needs to process one of the usual
1154              * complaints) and {de,en}cryption although needs some time.
1155              * So, before you complain about this limitation, I suggest that
1156              * you start a discussion with Marvin about this theme and then
1157              * do whatever you want. */
1158             tty_printf(_("keysize too large; %d is largest value allowed.\n"),
1159                                                                          4096);
1160         }
1161         else if( nbits > 2048 && !cpr_enabled() ) {
1162             tty_printf(
1163                 _("Keysizes larger than 2048 are not suggested because\n"
1164                   "computations take REALLY long!\n"));
1165             if( cpr_get_answer_is_yes("keygen.size.huge.okay",_(
1166                         "Are you sure that you want this keysize? ")) ) {
1167                 tty_printf(_("Okay, but keep in mind that your monitor "
1168                              "and keyboard radiation is also very vulnerable "
1169                              "to attacks!\n"));
1170                 break;
1171             }
1172         }
1173         else
1174             break;
1175     }
1176     tty_printf(_("Requested keysize is %u bits\n"), nbits );
1177     if( algo == PUBKEY_ALGO_DSA && (nbits % 64) ) {
1178         nbits = ((nbits + 63) / 64) * 64;
1179         tty_printf(_("rounded up to %u bits\n"), nbits );
1180     }
1181     else if( (nbits % 32) ) {
1182         nbits = ((nbits + 31) / 32) * 32;
1183         tty_printf(_("rounded up to %u bits\n"), nbits );
1184     }
1185     return nbits;
1186 }
1187
1188
1189 /****************
1190  * Parse an expire string and return it's value in days.
1191  * Returns -1 on error.
1192  */
1193 static int
1194 parse_expire_string( const char *string )
1195 {
1196     int mult;
1197     u32 abs_date=0;
1198     u32 curtime = make_timestamp();
1199     int valid_days;
1200
1201     if( !*string )
1202         valid_days = 0;
1203     else if( (abs_date = scan_isodatestr(string)) && abs_date > curtime ) {
1204         /* This calculation is not perfectly okay because we
1205          * are later going to simply multiply by 86400 and don't
1206          * correct for leapseconds.  A solution would be to change
1207          * the whole implemenation to work with dates and not intervals
1208          * which are required for v3 keys.
1209          */
1210         valid_days = abs_date/86400-curtime/86400+1;
1211     }
1212     else if( (mult=check_valid_days(string)) ) {
1213         valid_days = atoi(string) * mult;
1214         if( valid_days < 0 || valid_days > 39447 )
1215             valid_days = 0;
1216     }
1217     else {
1218         valid_days = -1;
1219     }
1220     return valid_days;
1221 }
1222
1223 /* object == 0 for a key, and 1 for a sig */
1224 u32
1225 ask_expire_interval(int object)
1226 {
1227     char *answer;
1228     int valid_days=0;
1229     u32 interval = 0;
1230
1231     switch(object)
1232       {
1233       case 0:
1234         tty_printf(_("Please specify how long the key should be valid.\n"
1235                      "         0 = key does not expire\n"
1236                      "      <n>  = key expires in n days\n"
1237                      "      <n>w = key expires in n weeks\n"
1238                      "      <n>m = key expires in n months\n"
1239                      "      <n>y = key expires in n years\n"));
1240         break;
1241
1242       case 1:
1243         tty_printf(_("Please specify how long the signature should be valid.\n"
1244                      "         0 = signature does not expire\n"
1245                      "      <n>  = signature expires in n days\n"
1246                      "      <n>w = signature expires in n weeks\n"
1247                      "      <n>m = signature expires in n months\n"
1248                      "      <n>y = signature expires in n years\n"));
1249         break;
1250
1251       default:
1252         BUG();
1253       }
1254
1255     /* Note: The elgamal subkey for DSA has no expiration date because
1256      * it must be signed with the DSA key and this one has the expiration
1257      * date */
1258
1259     answer = NULL;
1260     for(;;) {
1261         u32 curtime=make_timestamp();
1262
1263         m_free(answer);
1264         if(object==0)
1265           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
1266         else
1267           answer = cpr_get("siggen.valid",_("Signature is valid for? (0) "));
1268         cpr_kill_prompt();
1269         trim_spaces(answer);
1270         valid_days = parse_expire_string( answer );
1271         if( valid_days < 0 ) {
1272             tty_printf(_("invalid value\n"));
1273             continue;
1274         }
1275
1276         if( !valid_days ) {
1277             tty_printf(_("%s does not expire at all\n"),
1278                        object==0?"Key":"Signature");
1279             interval = 0;
1280         }
1281         else {
1282             interval = valid_days * 86400L;
1283             /* print the date when the key expires */
1284             tty_printf(_("%s expires at %s\n"),
1285                         object==0?"Key":"Signature",
1286                         asctimestamp((ulong)(curtime + interval) ) );
1287             /* FIXME: This check yields warning on alhas:
1288                write a configure check and to this check here only for 32 bit machines */
1289             if( (time_t)((ulong)(curtime+interval)) < 0 )
1290                 tty_printf(_("Your system can't display dates beyond 2038.\n"
1291                     "However, it will be correctly handled up to 2106.\n"));
1292         }
1293
1294         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
1295                                             _("Is this correct (y/n)? ")) )
1296             break;
1297     }
1298     m_free(answer);
1299     return interval;
1300 }
1301
1302 u32
1303 ask_expiredate()
1304 {
1305     u32 x = ask_expire_interval(0);
1306     return x? make_timestamp() + x : 0;
1307 }
1308
1309 static int
1310 has_invalid_email_chars( const char *s )
1311 {
1312     int at_seen=0;
1313     static char valid_chars[] = "01234567890_-."
1314                                 "abcdefghijklmnopqrstuvwxyz"
1315                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1316
1317     for( ; *s; s++ ) {
1318         if( *s & 0x80 )
1319             return 1;
1320         if( *s == '@' )
1321             at_seen=1;
1322         else if( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1323             return 1;
1324         else if( at_seen && !strchr( valid_chars, *s ) )
1325             return 1;
1326     }
1327     return 0;
1328 }
1329
1330
1331 static char *
1332 ask_user_id( int mode )
1333 {
1334     char *answer;
1335     char *aname, *acomment, *amail, *uid;
1336
1337     if( !mode )
1338         tty_printf( _("\n"
1339 "You need a User-ID to identify your key; the software constructs the user id\n"
1340 "from Real Name, Comment and Email Address in this form:\n"
1341 "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n") );
1342     uid = aname = acomment = amail = NULL;
1343     for(;;) {
1344         char *p;
1345         int fail=0;
1346
1347         if( !aname ) {
1348             for(;;) {
1349                 m_free(aname);
1350                 aname = cpr_get("keygen.name",_("Real name: "));
1351                 trim_spaces(aname);
1352                 cpr_kill_prompt();
1353
1354                 if( opt.allow_freeform_uid )
1355                     break;
1356
1357                 if( strpbrk( aname, "<>" ) )
1358                     tty_printf(_("Invalid character in name\n"));
1359                 else if( digitp(aname) )
1360                     tty_printf(_("Name may not start with a digit\n"));
1361                 else if( strlen(aname) < 5 )
1362                     tty_printf(_("Name must be at least 5 characters long\n"));
1363                 else
1364                     break;
1365             }
1366         }
1367         if( !amail ) {
1368             for(;;) {
1369                 m_free(amail);
1370                 amail = cpr_get("keygen.email",_("Email address: "));
1371                 trim_spaces(amail);
1372                 cpr_kill_prompt();
1373                 if( !*amail || opt.allow_freeform_uid )
1374                     break;   /* no email address is okay */
1375                 else if( has_invalid_email_chars(amail)
1376                          || string_count_chr(amail,'@') != 1
1377                          || *amail == '@'
1378                          || amail[strlen(amail)-1] == '@'
1379                          || amail[strlen(amail)-1] == '.'
1380                          || strstr(amail, "..") )
1381                     tty_printf(_("Not a valid email address\n"));
1382                 else
1383                     break;
1384             }
1385         }
1386         if( !acomment ) {
1387             for(;;) {
1388                 m_free(acomment);
1389                 acomment = cpr_get("keygen.comment",_("Comment: "));
1390                 trim_spaces(acomment);
1391                 cpr_kill_prompt();
1392                 if( !*acomment )
1393                     break;   /* no comment is okay */
1394                 else if( strpbrk( acomment, "()" ) )
1395                     tty_printf(_("Invalid character in comment\n"));
1396                 else
1397                     break;
1398             }
1399         }
1400
1401
1402         m_free(uid);
1403         uid = p = m_alloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
1404         p = stpcpy(p, aname );
1405         if( *acomment )
1406             p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
1407         if( *amail )
1408             p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
1409
1410         /* append a warning if we do not have dev/random
1411          * or it is switched into  quick testmode */
1412         if( quick_random_gen(-1) )
1413             strcpy(p, " (INSECURE!)" );
1414
1415         /* print a note in case that UTF8 mapping has to be done */
1416         for(p=uid; *p; p++ ) {
1417             if( *p & 0x80 ) {
1418                 tty_printf(_("You are using the `%s' character set.\n"),
1419                            get_native_charset() );
1420                 break;
1421             }
1422         }
1423
1424         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
1425         /* fixme: add a warning if this user-id already exists */
1426         if( !*amail && !opt.allow_freeform_uid
1427             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
1428             fail = 1;
1429             tty_printf(_("Please don't put the email address "
1430                           "into the real name or the comment\n") );
1431         }
1432
1433         for(;;) {
1434             const char *ansstr = _("NnCcEeOoQq");
1435
1436             if( strlen(ansstr) != 10 )
1437                 BUG();
1438             if( cpr_enabled() ) {
1439                 answer = m_strdup(ansstr+6);
1440                 answer[1] = 0;
1441             }
1442             else {
1443                 answer = cpr_get("keygen.userid.cmd", fail?
1444                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
1445                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
1446                 cpr_kill_prompt();
1447             }
1448             if( strlen(answer) > 1 )
1449                 ;
1450             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
1451                 m_free(aname); aname = NULL;
1452                 break;
1453             }
1454             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
1455                 m_free(acomment); acomment = NULL;
1456                 break;
1457             }
1458             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
1459                 m_free(amail); amail = NULL;
1460                 break;
1461             }
1462             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
1463                 if( fail ) {
1464                     tty_printf(_("Please correct the error first\n"));
1465                 }
1466                 else {
1467                     m_free(aname); aname = NULL;
1468                     m_free(acomment); acomment = NULL;
1469                     m_free(amail); amail = NULL;
1470                     break;
1471                 }
1472             }
1473             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
1474                 m_free(aname); aname = NULL;
1475                 m_free(acomment); acomment = NULL;
1476                 m_free(amail); amail = NULL;
1477                 m_free(uid); uid = NULL;
1478                 break;
1479             }
1480             m_free(answer);
1481         }
1482         m_free(answer);
1483         if( !amail && !acomment && !amail )
1484             break;
1485         m_free(uid); uid = NULL;
1486     }
1487     if( uid ) {
1488         char *p = native_to_utf8( uid );
1489         m_free( uid );
1490         uid = p;
1491     }
1492     return uid;
1493 }
1494
1495
1496 static DEK *
1497 do_ask_passphrase( STRING2KEY **ret_s2k )
1498 {
1499     DEK *dek = NULL;
1500     STRING2KEY *s2k;
1501     const char *errtext = NULL;
1502
1503     tty_printf(_("You need a Passphrase to protect your secret key.\n\n") );
1504
1505     s2k = m_alloc_secure( sizeof *s2k );
1506     for(;;) {
1507         s2k->mode = opt.s2k_mode;
1508         s2k->hash_algo = opt.s2k_digest_algo;
1509         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k,2,
1510                                  errtext, NULL);
1511         if( !dek ) {
1512             errtext = N_("passphrase not correctly repeated; try again");
1513             tty_printf(_("%s.\n"), _(errtext));
1514         }
1515         else if( !dek->keylen ) {
1516             m_free(dek); dek = NULL;
1517             m_free(s2k); s2k = NULL;
1518             tty_printf(_(
1519             "You don't want a passphrase - this is probably a *bad* idea!\n"
1520             "I will do it anyway.  You can change your passphrase at any time,\n"
1521             "using this program with the option \"--edit-key\".\n\n"));
1522             break;
1523         }
1524         else
1525             break; /* okay */
1526     }
1527     *ret_s2k = s2k;
1528     return dek;
1529 }
1530
1531
1532 static int
1533 do_create( int algo, unsigned int nbits, KBNODE pub_root, KBNODE sec_root,
1534            DEK *dek, STRING2KEY *s2k, PKT_secret_key **sk, u32 expiredate )
1535 {
1536     int rc=0;
1537
1538     if( !opt.batch )
1539         tty_printf(_(
1540 "We need to generate a lot of random bytes. It is a good idea to perform\n"
1541 "some other action (type on the keyboard, move the mouse, utilize the\n"
1542 "disks) during the prime generation; this gives the random number\n"
1543 "generator a better chance to gain enough entropy.\n") );
1544
1545     if( algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E )
1546         rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1547     else if( algo == PUBKEY_ALGO_DSA )
1548         rc = gen_dsa(nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1549     else if( algo == PUBKEY_ALGO_RSA )
1550         rc = gen_rsa(algo, nbits, pub_root, sec_root, dek, s2k, sk, expiredate);
1551     else
1552         BUG();
1553
1554 #ifdef ENABLE_COMMENT_PACKETS
1555     if( !rc ) {
1556         add_kbnode( pub_root,
1557                 make_comment_node("#created by GNUPG v" VERSION " ("
1558                                             PRINTABLE_OS_NAME ")"));
1559         add_kbnode( sec_root,
1560                 make_comment_node("#created by GNUPG v" VERSION " ("
1561                                             PRINTABLE_OS_NAME ")"));
1562     }
1563 #endif
1564     return rc;
1565 }
1566
1567
1568 /****************
1569  * Generate a new user id packet, or return NULL if canceled
1570  */
1571 PKT_user_id *
1572 generate_user_id()
1573 {
1574     PKT_user_id *uid;
1575     char *p;
1576     size_t n;
1577
1578     p = ask_user_id( 1 );
1579     if( !p )
1580         return NULL;
1581     n = strlen(p);
1582     uid = m_alloc_clear( sizeof *uid + n - 1 );
1583     uid->len = n;
1584     strcpy(uid->name, p);
1585     uid->ref = 1;
1586     return uid;
1587 }
1588
1589
1590 static void
1591 release_parameter_list( struct para_data_s *r )
1592 {
1593     struct para_data_s *r2;
1594
1595     for( ; r ; r = r2 ) {
1596         r2 = r->next;
1597         if( r->key == pPASSPHRASE_DEK )
1598             m_free( r->u.dek );
1599         else if( r->key == pPASSPHRASE_S2K )
1600             m_free( r->u.s2k );
1601
1602         m_free(r);
1603     }
1604 }
1605
1606 static struct para_data_s *
1607 get_parameter( struct para_data_s *para, enum para_name key )
1608 {
1609     struct para_data_s *r;
1610
1611     for( r = para; r && r->key != key; r = r->next )
1612         ;
1613     return r;
1614 }
1615
1616 static const char *
1617 get_parameter_value( struct para_data_s *para, enum para_name key )
1618 {
1619     struct para_data_s *r = get_parameter( para, key );
1620     return (r && *r->u.value)? r->u.value : NULL;
1621 }
1622
1623 static int
1624 get_parameter_algo( struct para_data_s *para, enum para_name key )
1625 {
1626     int i;
1627     struct para_data_s *r = get_parameter( para, key );
1628     if( !r )
1629         return -1;
1630     if( digitp( r->u.value ) )
1631         i = atoi( r->u.value );
1632     else
1633         i = string_to_pubkey_algo( r->u.value );
1634     if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
1635       i = 0; /* we don't want to allow generation of these algorithms */
1636     return i;
1637 }
1638
1639 /* 
1640  * parse the usage parameter and set the keyflags.  Return true on error.
1641  */
1642 static int
1643 parse_parameter_usage (const char *fname,
1644                        struct para_data_s *para, enum para_name key)
1645 {
1646     struct para_data_s *r = get_parameter( para, key );
1647     char *p, *pn;
1648     unsigned int use;
1649
1650     if( !r )
1651         return 0; /* none (this is an optional parameter)*/
1652     
1653     use = 0;
1654     pn = r->u.value;
1655     while ( (p = strsep (&pn, " \t,")) ) {
1656         if ( !*p)
1657             ;
1658         else if ( !ascii_strcasecmp (p, "sign") )
1659             use |= PUBKEY_USAGE_SIG;
1660         else if ( !ascii_strcasecmp (p, "encrypt") )
1661             use |= PUBKEY_USAGE_ENC;
1662         else if ( !ascii_strcasecmp (p, "auth") )
1663             use |= PUBKEY_USAGE_AUTH;
1664         else {
1665             log_error("%s:%d: invalid usage list\n", fname, r->lnr );
1666             return -1; /* error */
1667         }
1668     }
1669     r->u.usage = use;
1670     return 0;
1671 }
1672
1673 static int
1674 parse_revocation_key (const char *fname,
1675                       struct para_data_s *para, enum para_name key)
1676 {
1677   struct para_data_s *r = get_parameter( para, key );
1678   struct revocation_key revkey;
1679   char *pn;
1680   int i;
1681
1682   if( !r )
1683     return 0; /* none (this is an optional parameter) */
1684
1685   pn = r->u.value;
1686
1687   revkey.class=0x80;
1688   revkey.algid=atoi(pn);
1689   if(!revkey.algid)
1690     goto fail;
1691
1692   /* Skip to the fpr */
1693   while(*pn && *pn!=':')
1694     pn++;
1695
1696   if(*pn!=':')
1697     goto fail;
1698
1699   pn++;
1700
1701   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
1702     {
1703       int c=hextobyte(pn);
1704       if(c==-1)
1705         goto fail;
1706
1707       revkey.fpr[i]=c;
1708     }
1709
1710   /* skip to the tag */
1711   while(*pn && *pn!='s' && *pn!='S')
1712     pn++;
1713
1714   if(ascii_strcasecmp(pn,"sensitive")==0)
1715     revkey.class|=0x40;
1716
1717   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
1718
1719   return 0;
1720
1721   fail:
1722   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
1723   return -1; /* error */
1724 }
1725
1726
1727 static u32
1728 get_parameter_u32( struct para_data_s *para, enum para_name key )
1729 {
1730     struct para_data_s *r = get_parameter( para, key );
1731
1732     if( !r )
1733         return 0;
1734     if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
1735         return r->u.expire;
1736     if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
1737         return r->u.usage;
1738
1739     return (unsigned int)strtoul( r->u.value, NULL, 10 );
1740 }
1741
1742 static unsigned int
1743 get_parameter_uint( struct para_data_s *para, enum para_name key )
1744 {
1745     return get_parameter_u32( para, key );
1746 }
1747
1748 static DEK *
1749 get_parameter_dek( struct para_data_s *para, enum para_name key )
1750 {
1751     struct para_data_s *r = get_parameter( para, key );
1752     return r? r->u.dek : NULL;
1753 }
1754
1755 static STRING2KEY *
1756 get_parameter_s2k( struct para_data_s *para, enum para_name key )
1757 {
1758     struct para_data_s *r = get_parameter( para, key );
1759     return r? r->u.s2k : NULL;
1760 }
1761
1762 static struct revocation_key *
1763 get_parameter_revkey( struct para_data_s *para, enum para_name key )
1764 {
1765     struct para_data_s *r = get_parameter( para, key );
1766     return r? &r->u.revkey : NULL;
1767 }
1768
1769 static int
1770 proc_parameter_file( struct para_data_s *para, const char *fname,
1771                      struct output_control_s *outctrl, int card )
1772 {
1773     struct para_data_s *r;
1774     const char *s1, *s2, *s3;
1775     size_t n;
1776     char *p;
1777     int i;
1778
1779     /* check that we have all required parameters */
1780     assert( get_parameter( para, pKEYTYPE ) );
1781     i = get_parameter_algo( para, pKEYTYPE );
1782     if( i < 1 || check_pubkey_algo2( i, PUBKEY_USAGE_SIG ) ) {
1783         r = get_parameter( para, pKEYTYPE );
1784         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1785         return -1;
1786     }
1787
1788     if (parse_parameter_usage (fname, para, pKEYUSAGE))
1789         return -1;
1790
1791     i = get_parameter_algo( para, pSUBKEYTYPE );
1792     if( i > 0 && check_pubkey_algo( i ) ) {
1793         r = get_parameter( para, pSUBKEYTYPE );
1794         log_error("%s:%d: invalid algorithm\n", fname, r->lnr );
1795         return -1;
1796     }
1797     if (i > 0 && parse_parameter_usage (fname, para, pSUBKEYUSAGE))
1798         return -1;
1799
1800
1801     if( !get_parameter_value( para, pUSERID ) ) {
1802         /* create the formatted user ID */
1803         s1 = get_parameter_value( para, pNAMEREAL );
1804         s2 = get_parameter_value( para, pNAMECOMMENT );
1805         s3 = get_parameter_value( para, pNAMEEMAIL );
1806         if( s1 || s2 || s3 ) {
1807             n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
1808             r = m_alloc_clear( sizeof *r + n + 20 );
1809             r->key = pUSERID;
1810             p = r->u.value;
1811             if( s1 )
1812                 p = stpcpy(p, s1 );
1813             if( s2 )
1814                 p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
1815             if( s3 )
1816                 p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
1817             r->next = para;
1818             para = r;
1819         }
1820     }
1821
1822     /* Set preferences, if any. */
1823     keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
1824
1825     /* Set revoker, if any. */
1826     if (parse_revocation_key (fname, para, pREVOKER))
1827       return -1;
1828
1829     /* make DEK and S2K from the Passphrase */
1830     r = get_parameter( para, pPASSPHRASE );
1831     if( r && *r->u.value ) {
1832         /* we have a plain text passphrase - create a DEK from it.
1833          * It is a little bit ridiculous to keep it ih secure memory
1834          * but becuase we do this alwasy, why not here */
1835         STRING2KEY *s2k;
1836         DEK *dek;
1837
1838         s2k = m_alloc_secure( sizeof *s2k );
1839         s2k->mode = opt.s2k_mode;
1840         s2k->hash_algo = opt.s2k_digest_algo;
1841         set_next_passphrase( r->u.value );
1842         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
1843                                  NULL, NULL);
1844         set_next_passphrase( NULL );
1845         assert( dek );
1846         memset( r->u.value, 0, strlen(r->u.value) );
1847
1848         r = m_alloc_clear( sizeof *r );
1849         r->key = pPASSPHRASE_S2K;
1850         r->u.s2k = s2k;
1851         r->next = para;
1852         para = r;
1853         r = m_alloc_clear( sizeof *r );
1854         r->key = pPASSPHRASE_DEK;
1855         r->u.dek = dek;
1856         r->next = para;
1857         para = r;
1858     }
1859
1860     /* make KEYEXPIRE from Expire-Date */
1861     r = get_parameter( para, pEXPIREDATE );
1862     if( r && *r->u.value ) {
1863         i = parse_expire_string( r->u.value );
1864         if( i < 0 ) {
1865             log_error("%s:%d: invalid expire date\n", fname, r->lnr );
1866             return -1;
1867         }
1868         r->u.expire = i * 86400L;
1869         r->key = pKEYEXPIRE;  /* change hat entry */
1870         /* also set it for the subkey */
1871         r = m_alloc_clear( sizeof *r + 20 );
1872         r->key = pSUBKEYEXPIRE;
1873         r->u.expire = i * 86400L;
1874         r->next = para;
1875         para = r;
1876     }
1877
1878     if( !!outctrl->pub.newfname ^ !!outctrl->sec.newfname ) {
1879         log_error("%s:%d: only one ring name is set\n", fname, outctrl->lnr );
1880         return -1;
1881     }
1882
1883     do_generate_keypair( para, outctrl, card );
1884     return 0;
1885 }
1886
1887
1888 /****************
1889  * Kludge to allow non interactive key generation controlled
1890  * by a parameter file (which currently is only stdin)
1891  * Note, that string parameters are expected to be in UTF-8
1892  */
1893 static void
1894 read_parameter_file( const char *fname )
1895 {
1896     static struct { const char *name;
1897                     enum para_name key;
1898     } keywords[] = {
1899         { "Key-Type",       pKEYTYPE},
1900         { "Key-Length",     pKEYLENGTH },
1901         { "Key-Usage",      pKEYUSAGE },
1902         { "Subkey-Type",    pSUBKEYTYPE },
1903         { "Subkey-Length",  pSUBKEYLENGTH },
1904         { "Subkey-Usage",   pSUBKEYUSAGE },
1905         { "Name-Real",      pNAMEREAL },
1906         { "Name-Email",     pNAMEEMAIL },
1907         { "Name-Comment",   pNAMECOMMENT },
1908         { "Expire-Date",    pEXPIREDATE },
1909         { "Passphrase",     pPASSPHRASE },
1910         { "Preferences",    pPREFERENCES },
1911         { "Revoker",        pREVOKER },
1912         { NULL, 0 }
1913     };
1914     FILE *fp;
1915     char line[1024], *p;
1916     int lnr;
1917     const char *err = NULL;
1918     struct para_data_s *para, *r;
1919     int i;
1920     struct output_control_s outctrl;
1921
1922     memset( &outctrl, 0, sizeof( outctrl ) );
1923
1924     if( !fname || !*fname || !strcmp(fname,"-") ) {
1925         fp = stdin;
1926         fname = "-";
1927     }
1928     else {
1929         fp = fopen( fname, "r" );
1930         if( !fp ) {
1931             log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
1932             return;
1933         }
1934     }
1935
1936     lnr = 0;
1937     err = NULL;
1938     para = NULL;
1939     while( fgets( line, DIM(line)-1, fp ) ) {
1940         char *keyword, *value;
1941
1942         lnr++;
1943         if( *line && line[strlen(line)-1] != '\n' ) {
1944             err = "line too long";
1945             break;
1946         }
1947         for( p = line; isspace(*(byte*)p); p++ )
1948             ;
1949         if( !*p || *p == '#' )
1950             continue;
1951         keyword = p;
1952         if( *keyword == '%' ) {
1953             for( ; !isspace(*(byte*)p); p++ )
1954                 ;
1955             if( *p )
1956                 *p++ = 0;
1957             for( ; isspace(*(byte*)p); p++ )
1958                 ;
1959             value = p;
1960             trim_trailing_ws( value, strlen(value) );
1961             if( !ascii_strcasecmp( keyword, "%echo" ) )
1962                 log_info("%s\n", value );
1963             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
1964                 outctrl.dryrun = 1;
1965             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
1966                 outctrl.lnr = lnr;
1967                 proc_parameter_file( para, fname, &outctrl, 0 );
1968                 release_parameter_list( para );
1969                 para = NULL;
1970             }
1971             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
1972                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
1973                     ; /* still the same file - ignore it */
1974                 else {
1975                     m_free( outctrl.pub.newfname );
1976                     outctrl.pub.newfname = m_strdup( value );
1977                     outctrl.use_files = 1;
1978                 }
1979             }
1980             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
1981                 if( outctrl.sec.fname && !strcmp( outctrl.sec.fname, value ) )
1982                     ; /* still the same file - ignore it */
1983                 else {
1984                    m_free( outctrl.sec.newfname );
1985                    outctrl.sec.newfname = m_strdup( value );
1986                    outctrl.use_files = 1;
1987                 }
1988             }
1989             else
1990                 log_info("skipping control `%s' (%s)\n", keyword, value );
1991
1992
1993             continue;
1994         }
1995
1996
1997         if( !(p = strchr( p, ':' )) || p == keyword ) {
1998             err = "missing colon";
1999             break;
2000         }
2001         if( *p )
2002             *p++ = 0;
2003         for( ; isspace(*(byte*)p); p++ )
2004             ;
2005         if( !*p ) {
2006             err = "missing argument";
2007             break;
2008         }
2009         value = p;
2010         trim_trailing_ws( value, strlen(value) );
2011
2012         for(i=0; keywords[i].name; i++ ) {
2013             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
2014                 break;
2015         }
2016         if( !keywords[i].name ) {
2017             err = "unknown keyword";
2018             break;
2019         }
2020         if( keywords[i].key != pKEYTYPE && !para ) {
2021             err = "parameter block does not start with \"Key-Type\"";
2022             break;
2023         }
2024
2025         if( keywords[i].key == pKEYTYPE && para ) {
2026             outctrl.lnr = lnr;
2027             proc_parameter_file( para, fname, &outctrl, 0 );
2028             release_parameter_list( para );
2029             para = NULL;
2030         }
2031         else {
2032             for( r = para; r; r = r->next ) {
2033                 if( r->key == keywords[i].key )
2034                     break;
2035             }
2036             if( r ) {
2037                 err = "duplicate keyword";
2038                 break;
2039             }
2040         }
2041         r = m_alloc_clear( sizeof *r + strlen( value ) );
2042         r->lnr = lnr;
2043         r->key = keywords[i].key;
2044         strcpy( r->u.value, value );
2045         r->next = para;
2046         para = r;
2047     }
2048     if( err )
2049         log_error("%s:%d: %s\n", fname, lnr, err );
2050     else if( ferror(fp) ) {
2051         log_error("%s:%d: read error: %s\n", fname, lnr, strerror(errno) );
2052     }
2053     else if( para ) {
2054         outctrl.lnr = lnr;
2055         proc_parameter_file( para, fname, &outctrl, 0 );
2056     }
2057
2058     if( outctrl.use_files ) { /* close open streams */
2059         iobuf_close( outctrl.pub.stream );
2060         iobuf_close( outctrl.sec.stream );
2061         m_free( outctrl.pub.fname );
2062         m_free( outctrl.pub.newfname );
2063         m_free( outctrl.sec.fname );
2064         m_free( outctrl.sec.newfname );
2065     }
2066
2067     release_parameter_list( para );
2068     if( strcmp( fname, "-" ) )
2069         fclose(fp);
2070 }
2071
2072
2073 /*
2074  * Generate a keypair (fname is only used in batch mode) If
2075  * CARD_SERIALNO is not NULL the fucntion will create the keys on an
2076  * OpenPGP Card.
2077  */
2078 void
2079 generate_keypair( const char *fname, const char *card_serialno )
2080 {
2081   unsigned int nbits;
2082   char *uid = NULL;
2083   DEK *dek;
2084   STRING2KEY *s2k;
2085   int algo;
2086   unsigned int use;
2087   int both = 0;
2088   u32 expire;
2089   struct para_data_s *para = NULL;
2090   struct para_data_s *r;
2091   struct output_control_s outctrl;
2092   
2093   memset( &outctrl, 0, sizeof( outctrl ) );
2094   
2095   if (opt.batch && card_serialno)
2096     {
2097       /* We don't yet support unattended key generation. */
2098       log_error (_("sorry, can't do this in batch mode\n"));
2099       return;
2100     }
2101   
2102    if (opt.batch)
2103      {
2104        read_parameter_file( fname );
2105        return;
2106      }
2107
2108    if (card_serialno)
2109      {
2110 #ifdef ENABLE_CARD_SUPPORT
2111        r = xcalloc (1, sizeof *r + strlen (card_serialno) );
2112        r->key = pSERIALNO;
2113        strcpy( r->u.value, card_serialno);
2114        r->next = para;
2115        para = r;
2116        
2117        algo = PUBKEY_ALGO_RSA;
2118        
2119        r = xcalloc (1, sizeof *r + 20 );
2120        r->key = pKEYTYPE;
2121        sprintf( r->u.value, "%d", algo );
2122        r->next = para;
2123        para = r;
2124        r = xcalloc (1, sizeof *r + 20 );
2125        r->key = pKEYUSAGE;
2126        strcpy (r->u.value, "sign");
2127        r->next = para;
2128        para = r;
2129        
2130        r = xcalloc (1, sizeof *r + 20 );
2131        r->key = pSUBKEYTYPE;
2132        sprintf( r->u.value, "%d", algo );
2133        r->next = para;
2134        para = r;
2135        r = xcalloc (1, sizeof *r + 20 );
2136        r->key = pSUBKEYUSAGE;
2137        strcpy (r->u.value, "encrypt");
2138        r->next = para;
2139        para = r;
2140        
2141        r = xcalloc (1, sizeof *r + 20 );
2142        r->key = pAUTHKEYTYPE;
2143        sprintf( r->u.value, "%d", algo );
2144        r->next = para;
2145        para = r;
2146 #endif /*ENABLE_CARD_SUPPORT*/
2147      }
2148    else
2149      {
2150        algo = ask_algo( 0, &use );
2151        if( !algo )
2152          { /* default: DSA with ElG subkey of the specified size */
2153            both = 1;
2154            r = m_alloc_clear( sizeof *r + 20 );
2155            r->key = pKEYTYPE;
2156            sprintf( r->u.value, "%d", PUBKEY_ALGO_DSA );
2157            r->next = para;
2158            para = r;
2159            tty_printf(_("DSA keypair will have 1024 bits.\n"));
2160            r = m_alloc_clear( sizeof *r + 20 );
2161            r->key = pKEYLENGTH;
2162            strcpy( r->u.value, "1024" );
2163            r->next = para;
2164            para = r;
2165            r = m_alloc_clear( sizeof *r + 20 );
2166            r->key = pKEYUSAGE;
2167            strcpy( r->u.value, "sign" );
2168            r->next = para;
2169            para = r;
2170            
2171            algo = PUBKEY_ALGO_ELGAMAL_E;
2172            r = m_alloc_clear( sizeof *r + 20 );
2173            r->key = pSUBKEYTYPE;
2174            sprintf( r->u.value, "%d", algo );
2175            r->next = para;
2176            para = r;
2177            r = m_alloc_clear( sizeof *r + 20 );
2178            r->key = pSUBKEYUSAGE;
2179            strcpy( r->u.value, "encrypt" );
2180            r->next = para;
2181            para = r;
2182          }
2183        else 
2184          {
2185            r = m_alloc_clear( sizeof *r + 20 );
2186            r->key = pKEYTYPE;
2187            sprintf( r->u.value, "%d", algo );
2188            r->next = para;
2189            para = r;
2190            
2191            if (use)
2192              {
2193                r = m_alloc_clear( sizeof *r + 20 );
2194                r->key = pKEYUSAGE;
2195                sprintf( r->u.value, "%s%s",
2196                         (use & PUBKEY_USAGE_SIG)? "sign ":"",
2197                         (use & PUBKEY_USAGE_ENC)? "encrypt ":"" );
2198                r->next = para;
2199                para = r;
2200              }
2201            
2202          }
2203        
2204        nbits = ask_keysize( algo );
2205        r = m_alloc_clear( sizeof *r + 20 );
2206        r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
2207        sprintf( r->u.value, "%u", nbits);
2208        r->next = para;
2209        para = r;
2210      }
2211
2212    expire = ask_expire_interval(0);
2213     r = m_alloc_clear( sizeof *r + 20 );
2214     r->key = pKEYEXPIRE;
2215     r->u.expire = expire;
2216     r->next = para;
2217     para = r;
2218     r = m_alloc_clear( sizeof *r + 20 );
2219     r->key = pSUBKEYEXPIRE;
2220     r->u.expire = expire;
2221     r->next = para;
2222     para = r;
2223
2224     uid = ask_user_id(0);
2225     if( !uid ) 
2226       {
2227         log_error(_("Key generation canceled.\n"));
2228         release_parameter_list( para );
2229         return;
2230       }
2231     r = m_alloc_clear( sizeof *r + strlen(uid) );
2232     r->key = pUSERID;
2233     strcpy( r->u.value, uid );
2234     r->next = para;
2235     para = r;
2236     
2237     dek = card_serialno? NULL : do_ask_passphrase( &s2k );
2238     if( dek )
2239       {
2240         r = m_alloc_clear( sizeof *r );
2241         r->key = pPASSPHRASE_DEK;
2242         r->u.dek = dek;
2243         r->next = para;
2244         para = r;
2245         r = m_alloc_clear( sizeof *r );
2246         r->key = pPASSPHRASE_S2K;
2247         r->u.s2k = s2k;
2248         r->next = para;
2249         para = r;
2250       }
2251     
2252     proc_parameter_file( para, "[internal]", &outctrl, !!card_serialno);
2253     release_parameter_list( para );
2254 }
2255
2256
2257 static void
2258 print_status_key_created (int letter, PKT_public_key *pk)
2259 {
2260   byte array[MAX_FINGERPRINT_LEN], *s;
2261   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
2262   size_t i, n;
2263   
2264   p = buf;
2265   *p++ = letter;
2266   *p++ = ' ';
2267   fingerprint_from_pk (pk, array, &n);
2268   s = array;
2269   for (i=0; i < n ; i++, s++, p += 2)
2270     sprintf (p, "%02X", *s);
2271   *p = 0;
2272   write_status_text (STATUS_KEY_CREATED, buf);
2273 }
2274
2275 static void
2276 do_generate_keypair( struct para_data_s *para,
2277                      struct output_control_s *outctrl, int card )
2278 {
2279     KBNODE pub_root = NULL;
2280     KBNODE sec_root = NULL;
2281     PKT_secret_key *sk = NULL;
2282     const char *s;
2283     struct revocation_key *revkey;
2284     int rc;
2285     int did_sub = 0;
2286
2287     if( outctrl->dryrun ) {
2288         log_info("dry-run mode - key generation skipped\n");
2289         return;
2290     }
2291
2292
2293     if( outctrl->use_files ) {
2294         if( outctrl->pub.newfname ) {
2295             iobuf_close(outctrl->pub.stream);
2296             outctrl->pub.stream = NULL;
2297             m_free( outctrl->pub.fname );
2298             outctrl->pub.fname =  outctrl->pub.newfname;
2299             outctrl->pub.newfname = NULL;
2300
2301             outctrl->pub.stream = iobuf_create( outctrl->pub.fname );
2302             if( !outctrl->pub.stream ) {
2303                 log_error("can't create `%s': %s\n", outctrl->pub.newfname,
2304                                                      strerror(errno) );
2305                 return;
2306             }
2307             if( opt.armor ) {
2308                 outctrl->pub.afx.what = 1;
2309                 iobuf_push_filter( outctrl->pub.stream, armor_filter,
2310                                                     &outctrl->pub.afx );
2311             }
2312         }
2313         if( outctrl->sec.newfname ) {
2314             iobuf_close(outctrl->sec.stream);
2315             outctrl->sec.stream = NULL;
2316             m_free( outctrl->sec.fname );
2317             outctrl->sec.fname =  outctrl->sec.newfname;
2318             outctrl->sec.newfname = NULL;
2319
2320             outctrl->sec.stream = iobuf_create( outctrl->sec.fname );
2321             if( !outctrl->sec.stream ) {
2322                 log_error("can't create `%s': %s\n", outctrl->sec.newfname,
2323                                                      strerror(errno) );
2324                 return;
2325             }
2326             if( opt.armor ) {
2327                 outctrl->sec.afx.what = 5;
2328                 iobuf_push_filter( outctrl->sec.stream, armor_filter,
2329                                                     &outctrl->sec.afx );
2330             }
2331         }
2332         assert( outctrl->pub.stream );
2333         assert( outctrl->sec.stream );
2334         if( opt.verbose ) {
2335             log_info(_("writing public key to `%s'\n"), outctrl->pub.fname );
2336             if (card)
2337               log_info (_("writing secret key stub to `%s'\n"),
2338                         outctrl->sec.fname);
2339             else
2340               log_info(_("writing secret key to `%s'\n"), outctrl->sec.fname );
2341         }
2342     }
2343
2344
2345     /* we create the packets as a tree of kbnodes. Because the structure
2346      * we create is known in advance we simply generate a linked list
2347      * The first packet is a dummy comment packet which we flag
2348      * as deleted.  The very first packet must always be a KEY packet.
2349      */
2350     pub_root = make_comment_node("#"); delete_kbnode(pub_root);
2351     sec_root = make_comment_node("#"); delete_kbnode(sec_root);
2352
2353     if (!card)
2354       {
2355         rc = do_create( get_parameter_algo( para, pKEYTYPE ),
2356                         get_parameter_uint( para, pKEYLENGTH ),
2357                         pub_root, sec_root,
2358                         get_parameter_dek( para, pPASSPHRASE_DEK ),
2359                         get_parameter_s2k( para, pPASSPHRASE_S2K ),
2360                         &sk,
2361                         get_parameter_u32( para, pKEYEXPIRE ) );
2362       }
2363     else
2364       {
2365         rc = gen_card_key (PUBKEY_ALGO_RSA, 1, pub_root, sec_root,
2366                            get_parameter_u32 (para, pKEYEXPIRE), para);
2367         if (!rc)
2368           {
2369             sk = sec_root->next->pkt->pkt.secret_key;
2370             assert (sk);
2371           }
2372       }
2373
2374     if(!rc && (revkey=get_parameter_revkey(para,pREVOKER)))
2375       {
2376         rc=write_direct_sig(pub_root,pub_root,sk,revkey);
2377         if(!rc)
2378           write_direct_sig(sec_root,pub_root,sk,revkey);
2379       }
2380
2381     if( !rc && (s=get_parameter_value(para, pUSERID)) ) {
2382         write_uid(pub_root, s );
2383         if( !rc )
2384             write_uid(sec_root, s );
2385         if( !rc )
2386             rc = write_selfsig(pub_root, pub_root, sk,
2387                                get_parameter_uint (para, pKEYUSAGE));
2388         if( !rc )
2389             rc = write_selfsig(sec_root, pub_root, sk,
2390                                get_parameter_uint (para, pKEYUSAGE));
2391     }
2392
2393     if( get_parameter( para, pSUBKEYTYPE ) )
2394       {
2395         if (!card)
2396           {
2397             rc = do_create( get_parameter_algo( para, pSUBKEYTYPE ),
2398                             get_parameter_uint( para, pSUBKEYLENGTH ),
2399                             pub_root, sec_root,
2400                             get_parameter_dek( para, pPASSPHRASE_DEK ),
2401                             get_parameter_s2k( para, pPASSPHRASE_S2K ),
2402                             NULL,
2403                             get_parameter_u32( para, pSUBKEYEXPIRE ) );
2404           }
2405         else
2406           {
2407             rc = gen_card_key (PUBKEY_ALGO_RSA, 2, pub_root, sec_root,
2408                                get_parameter_u32 (para, pKEYEXPIRE), para);
2409           }
2410
2411         if( !rc )
2412           rc = write_keybinding(pub_root, pub_root, sk,
2413                                 get_parameter_uint (para, pSUBKEYUSAGE));
2414         if( !rc )
2415           rc = write_keybinding(sec_root, pub_root, sk,
2416                                 get_parameter_uint (para, pSUBKEYUSAGE));
2417         did_sub = 1;
2418       }
2419
2420     if (card && get_parameter (para, pAUTHKEYTYPE))
2421       {
2422         rc = gen_card_key (PUBKEY_ALGO_RSA, 3, pub_root, sec_root,
2423                            get_parameter_u32 (para, pKEYEXPIRE), para);
2424         
2425         if (!rc)
2426           rc = write_keybinding (pub_root, pub_root, sk, PUBKEY_USAGE_AUTH);
2427         if (!rc)
2428           rc = write_keybinding (sec_root, pub_root, sk, PUBKEY_USAGE_AUTH);
2429       }
2430     
2431     if( !rc && outctrl->use_files ) { /* direct write to specified files */
2432         rc = write_keyblock( outctrl->pub.stream, pub_root );
2433         if( rc )
2434             log_error("can't write public key: %s\n", g10_errstr(rc) );
2435         if( !rc ) {
2436             rc = write_keyblock( outctrl->sec.stream, sec_root );
2437             if( rc )
2438                 log_error("can't write secret key: %s\n", g10_errstr(rc) );
2439         }
2440
2441     }
2442     else if( !rc ) { /* write to the standard keyrings */
2443         KEYDB_HANDLE pub_hd = keydb_new (0);
2444         KEYDB_HANDLE sec_hd = keydb_new (1);
2445
2446         /* FIXME: we may have to create the keyring first */
2447         rc = keydb_locate_writable (pub_hd, NULL);
2448         if (rc) 
2449             log_error (_("no writable public keyring found: %s\n"),
2450                        g10_errstr (rc));
2451
2452         if (!rc) {  
2453             rc = keydb_locate_writable (sec_hd, NULL);
2454             if (rc) 
2455                 log_error (_("no writable secret keyring found: %s\n"),
2456                            g10_errstr (rc));
2457         }
2458
2459         if (!rc && opt.verbose) {
2460             log_info(_("writing public key to `%s'\n"),
2461                      keydb_get_resource_name (pub_hd));
2462             if (card)
2463               log_info (_("writing secret key stub to `%s'\n"),
2464                         keydb_get_resource_name (sec_hd));
2465             else
2466               log_info(_("writing secret key to `%s'\n"),
2467                        keydb_get_resource_name (sec_hd));
2468         }
2469
2470         if (!rc) {
2471             rc = keydb_insert_keyblock (pub_hd, pub_root);
2472             if (rc)
2473                 log_error (_("error writing public keyring `%s': %s\n"),
2474                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2475         }
2476
2477         if (!rc) {
2478             rc = keydb_insert_keyblock (sec_hd, sec_root);
2479             if (rc)
2480                 log_error (_("error writing secret keyring `%s': %s\n"),
2481                            keydb_get_resource_name (pub_hd), g10_errstr(rc));
2482         }
2483
2484         keydb_release (pub_hd);
2485         keydb_release (sec_hd);
2486
2487         if (!rc) {
2488             int no_enc_rsa =
2489                 get_parameter_algo(para, pKEYTYPE) == PUBKEY_ALGO_RSA
2490                 && get_parameter_uint( para, pKEYUSAGE )
2491                 && !(get_parameter_uint( para,pKEYUSAGE) & PUBKEY_USAGE_ENC);
2492             PKT_public_key *pk = find_kbnode (pub_root, 
2493                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2494             
2495             update_ownertrust (pk,
2496                                ((get_ownertrust (pk) & ~TRUST_MASK)
2497                                 | TRUST_ULTIMATE ));
2498
2499             if (!opt.batch) {
2500                 tty_printf(_("public and secret key created and signed.\n") );
2501                 tty_printf(_("key marked as ultimately trusted.\n") );
2502                 tty_printf("\n");
2503                 list_keyblock(pub_root,0,1,NULL);
2504             }
2505             
2506
2507             if( !opt.batch
2508                 && ( get_parameter_algo( para, pKEYTYPE ) == PUBKEY_ALGO_DSA
2509                      || no_enc_rsa )
2510                 && !get_parameter( para, pSUBKEYTYPE ) )
2511             {
2512                 tty_printf(_("Note that this key cannot be used for "
2513                              "encryption.  You may want to use\n"
2514                              "the command \"--edit-key\" to generate a "
2515                              "secondary key for this purpose.\n") );
2516             }
2517         }
2518     }
2519
2520     if( rc ) {
2521         if( opt.batch )
2522             log_error("key generation failed: %s\n", g10_errstr(rc) );
2523         else
2524             tty_printf(_("Key generation failed: %s\n"), g10_errstr(rc) );
2525     }
2526     else {
2527         PKT_public_key *pk = find_kbnode (pub_root, 
2528                                     PKT_PUBLIC_KEY)->pkt->pkt.public_key;
2529         print_status_key_created (did_sub? 'B':'P', pk);
2530     }
2531     release_kbnode( pub_root );
2532     release_kbnode( sec_root );
2533     if( sk && !card) /* the unprotected  secret key unless we have a */
2534       free_secret_key(sk); /* shallow copy in card mode. */
2535 }
2536
2537
2538 /****************
2539  * add a new subkey to an existing key.
2540  * Returns true if a new key has been generated and put into the keyblocks.
2541  */
2542 int
2543 generate_subkeypair( KBNODE pub_keyblock, KBNODE sec_keyblock )
2544 {
2545     int okay=0, rc=0;
2546     KBNODE node;
2547     PKT_secret_key *sk = NULL; /* this is the primary sk */
2548     int algo;
2549     unsigned int use;
2550     u32 expire;
2551     unsigned nbits;
2552     char *passphrase = NULL;
2553     DEK *dek = NULL;
2554     STRING2KEY *s2k = NULL;
2555     u32 cur_time;
2556
2557     /* break out the primary secret key */
2558     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
2559     if( !node ) {
2560         log_error("Oops; secret key not found anymore!\n");
2561         goto leave;
2562     }
2563
2564     /* make a copy of the sk to keep the protected one in the keyblock */
2565     sk = copy_secret_key( NULL, node->pkt->pkt.secret_key );
2566
2567     cur_time = make_timestamp();
2568     if( sk->timestamp > cur_time ) {
2569         ulong d = sk->timestamp - cur_time;
2570         log_info( d==1 ? _("key has been created %lu second "
2571                            "in future (time warp or clock problem)\n")
2572                        : _("key has been created %lu seconds "
2573                            "in future (time warp or clock problem)\n"), d );
2574         if( !opt.ignore_time_conflict ) {
2575             rc = G10ERR_TIME_CONFLICT;
2576             goto leave;
2577         }
2578     }
2579
2580     if (sk->version < 4) {
2581         log_info (_("NOTE: creating subkeys for v3 keys "
2582                     "is not OpenPGP compliant\n"));
2583         goto leave;
2584     }
2585
2586     /* unprotect to get the passphrase */
2587     switch( is_secret_key_protected( sk ) ) {
2588       case -1:
2589         rc = G10ERR_PUBKEY_ALGO;
2590         break;
2591       case 0:
2592         tty_printf("This key is not protected.\n");
2593         break;
2594       default:
2595         tty_printf("Key is protected.\n");
2596         rc = check_secret_key( sk, 0 );
2597         if( !rc )
2598             passphrase = get_last_passphrase();
2599         break;
2600     }
2601     if( rc )
2602         goto leave;
2603
2604
2605     algo = ask_algo( 1, &use );
2606     assert(algo);
2607     nbits = ask_keysize( algo );
2608     expire = ask_expire_interval(0);
2609     if( !cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
2610                                                   _("Really create? ") ) )
2611         goto leave;
2612
2613     if( passphrase ) {
2614         s2k = m_alloc_secure( sizeof *s2k );
2615         s2k->mode = opt.s2k_mode;
2616         s2k->hash_algo = opt.s2k_digest_algo;
2617         set_next_passphrase( passphrase );
2618         dek = passphrase_to_dek( NULL, 0, opt.s2k_cipher_algo, s2k, 2,
2619                                  NULL, NULL );
2620     }
2621
2622     rc = do_create( algo, nbits, pub_keyblock, sec_keyblock,
2623                                       dek, s2k, NULL, expire );
2624     if( !rc )
2625         rc = write_keybinding(pub_keyblock, pub_keyblock, sk, use);
2626     if( !rc )
2627         rc = write_keybinding(sec_keyblock, pub_keyblock, sk, use);
2628     if( !rc ) {
2629         okay = 1;
2630         write_status_text (STATUS_KEY_CREATED, "S");
2631     }
2632
2633   leave:
2634     if( rc )
2635         log_error(_("Key generation failed: %s\n"), g10_errstr(rc) );
2636     m_free( passphrase );
2637     m_free( dek );
2638     m_free( s2k );
2639     if( sk ) /* release the copy of the (now unprotected) secret key */
2640         free_secret_key(sk);
2641     set_next_passphrase( NULL );
2642     return okay;
2643 }
2644
2645 /****************
2646  * Write a keyblock to an output stream
2647  */
2648 static int
2649 write_keyblock( IOBUF out, KBNODE node )
2650 {
2651     for( ; node ; node = node->next ) {
2652         int rc = build_packet( out, node->pkt );
2653         if( rc ) {
2654             log_error("build_packet(%d) failed: %s\n",
2655                         node->pkt->pkttype, g10_errstr(rc) );
2656             return G10ERR_WRITE_FILE;
2657         }
2658     }
2659     return 0;
2660 }
2661
2662
2663 static int
2664 gen_card_key (int algo, int keyno, KBNODE pub_root, KBNODE sec_root,
2665               u32 expireval, struct para_data_s *para)
2666 {
2667 #ifdef ENABLE_CARD_SUPPORT
2668   int rc;
2669   const char *s;
2670   struct agent_card_genkey_s info;
2671   PACKET *pkt;
2672   PKT_secret_key *sk;
2673   PKT_public_key *pk;
2674
2675   assert (algo == PUBKEY_ALGO_RSA);
2676
2677   rc = agent_scd_genkey (&info, keyno, 1);
2678 /*    if (gpg_err_code (rc) == GPG_ERR_EEXIST) */
2679 /*      { */
2680 /*        tty_printf ("\n"); */
2681 /*        log_error ("WARNING: key does already exists!\n"); */
2682 /*        tty_printf ("\n"); */
2683 /*        if ( cpr_get_answer_is_yes( "keygen.card.replace_key", */
2684 /*                                    _("Replace existing key? "))) */
2685 /*          rc = agent_scd_genkey (&info, keyno, 1); */
2686 /*      } */
2687
2688   if (rc)
2689     {
2690       log_error ("key generation failed: %s\n", gpg_strerror (rc));
2691       return rc;
2692     }
2693   if ( !info.n || !info.e )
2694     {
2695       log_error ("communication error with SCD\n");
2696       mpi_free (info.n);
2697       mpi_free (info.e);
2698       return gpg_error (GPG_ERR_GENERAL);
2699     }
2700   
2701
2702   pk = xcalloc (1, sizeof *pk );
2703   sk = xcalloc (1, sizeof *sk );
2704   sk->timestamp = pk->timestamp = info.created_at;
2705   sk->version = pk->version = 4;
2706   if (expireval)
2707       sk->expiredate = pk->expiredate = pk->timestamp + expireval;
2708   sk->pubkey_algo = pk->pubkey_algo = algo;
2709   pk->pkey[0] = info.n;
2710   pk->pkey[1] = info.e; 
2711   sk->skey[0] = mpi_copy (pk->pkey[0]);
2712   sk->skey[1] = mpi_copy (pk->pkey[1]);
2713   sk->skey[2] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
2714   sk->is_protected = 1;
2715   sk->protect.s2k.mode = 1002;
2716   s = get_parameter_value (para, pSERIALNO);
2717   if (s)
2718     {
2719       for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2720            sk->protect.ivlen++, s += 2)
2721         sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
2722     }
2723
2724   pkt = xcalloc (1,sizeof *pkt);
2725   pkt->pkttype = keyno == 1 ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
2726   pkt->pkt.public_key = pk;
2727   add_kbnode(pub_root, new_kbnode( pkt ));
2728
2729   pkt = xcalloc (1,sizeof *pkt);
2730   pkt->pkttype = keyno == 1 ? PKT_SECRET_KEY : PKT_SECRET_SUBKEY;
2731   pkt->pkt.secret_key = sk;
2732   add_kbnode(sec_root, new_kbnode( pkt ));
2733
2734   return 0;
2735 #else
2736   return -1;
2737 #endif /*!ENABLE_CARD_SUPPORT*/
2738 }