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