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