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