dcd2bd10bbd1d5e961113fe10200ac5f3b2ad6c5
[gnupg.git] / g10 / misc.c
1 /* misc.c - miscellaneous functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3  *               2008, 2009, 2010 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <errno.h>
27 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
28 #include <asm/sysinfo.h>
29 #include <asm/unistd.h>
30 #endif
31 #ifdef HAVE_SETRLIMIT
32 #include <time.h>
33 #include <sys/time.h>
34 #include <sys/resource.h>
35 #endif
36 #ifdef ENABLE_SELINUX_HACKS
37 #include <sys/stat.h>
38 #endif
39
40 #ifdef HAVE_W32_SYSTEM
41 #include <time.h>
42 #include <process.h>
43 #include <windows.h> 
44 #include <shlobj.h>
45 #ifndef CSIDL_APPDATA
46 #define CSIDL_APPDATA 0x001a
47 #endif
48 #ifndef CSIDL_LOCAL_APPDATA
49 #define CSIDL_LOCAL_APPDATA 0x001c
50 #endif
51 #ifndef CSIDL_FLAG_CREATE
52 #define CSIDL_FLAG_CREATE 0x8000
53 #endif
54 #endif /*HAVE_W32_SYSTEM*/
55
56 #include "gpg.h"
57 #ifdef HAVE_W32_SYSTEM
58 # include "status.h"
59 #endif /*HAVE_W32_SYSTEM*/
60 #include "util.h"
61 #include "main.h"
62 #include "photoid.h"
63 #include "options.h"
64 #include "call-agent.h"
65 #include "i18n.h"
66
67 #include <assert.h>
68
69 static int
70 string_count_chr (const char *string, int c)
71 {
72   int count;
73
74   for (count=0; *string; string++ )
75     if ( *string == c )
76       count++;
77   return count;
78 }
79
80
81
82 #ifdef ENABLE_SELINUX_HACKS
83 /* A object and a global variable to keep track of files marked as
84    secured. */
85 struct secured_file_item 
86 {
87   struct secured_file_item *next;
88   ino_t ino;
89   dev_t dev;
90 };
91 static struct secured_file_item *secured_files;
92 #endif /*ENABLE_SELINUX_HACKS*/
93
94
95
96
97 /* For the sake of SELinux we want to restrict access through gpg to
98    certain files we keep under our own control.  This function
99    registers such a file and is_secured_file may then be used to
100    check whether a file has ben registered as secured. */
101 void
102 register_secured_file (const char *fname)
103 {
104 #ifdef ENABLE_SELINUX_HACKS
105   struct stat buf;
106   struct secured_file_item *sf;
107
108   /* Note that we stop immediatley if something goes wrong here. */
109   if (stat (fname, &buf))
110     log_fatal (_("fstat of `%s' failed in %s: %s\n"), fname, 
111                "register_secured_file", strerror (errno));
112 /*   log_debug ("registering `%s' i=%lu.%lu\n", fname, */
113 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
114   for (sf=secured_files; sf; sf = sf->next)
115     {
116       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
117         return; /* Already registered.  */
118     }
119
120   sf = xmalloc (sizeof *sf);
121   sf->ino = buf.st_ino;
122   sf->dev = buf.st_dev;
123   sf->next = secured_files;
124   secured_files = sf;
125 #else /*!ENABLE_SELINUX_HACKS*/
126   (void)fname;
127 #endif /*!ENABLE_SELINUX_HACKS*/
128 }
129
130 /* Remove a file registered as secure. */
131 void
132 unregister_secured_file (const char *fname)
133 {
134 #ifdef ENABLE_SELINUX_HACKS
135   struct stat buf;
136   struct secured_file_item *sf, *sfprev;
137
138   if (stat (fname, &buf))
139     {
140       log_error (_("fstat of `%s' failed in %s: %s\n"), fname,
141                  "unregister_secured_file", strerror (errno));
142       return;
143     }
144 /*   log_debug ("unregistering `%s' i=%lu.%lu\n", fname,  */
145 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
146   for (sfprev=NULL,sf=secured_files; sf; sfprev=sf, sf = sf->next)
147     {
148       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
149         {
150           if (sfprev)
151             sfprev->next = sf->next;
152           else
153             secured_files = sf->next;
154           xfree (sf);
155           return;
156         }
157     }
158 #else /*!ENABLE_SELINUX_HACKS*/
159   (void)fname;
160 #endif /*!ENABLE_SELINUX_HACKS*/
161 }
162
163 /* Return true if FD is corresponds to a secured file.  Using -1 for
164    FS is allowed and will return false. */ 
165 int 
166 is_secured_file (int fd)
167 {
168 #ifdef ENABLE_SELINUX_HACKS
169   struct stat buf;
170   struct secured_file_item *sf;
171
172   if (fd == -1)
173     return 0; /* No file descriptor so it can't be secured either.  */
174
175   /* Note that we print out a error here and claim that a file is
176      secure if something went wrong. */
177   if (fstat (fd, &buf))
178     {
179       log_error (_("fstat(%d) failed in %s: %s\n"), fd, 
180                  "is_secured_file", strerror (errno));
181       return 1;
182     }
183 /*   log_debug ("is_secured_file (%d) i=%lu.%lu\n", fd, */
184 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
185   for (sf=secured_files; sf; sf = sf->next)
186     {
187       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
188         return 1; /* Yes.  */
189     }
190 #else /*!ENABLE_SELINUX_HACKS*/
191   (void)fd;
192 #endif /*!ENABLE_SELINUX_HACKS*/
193   return 0; /* No. */
194 }
195
196 /* Return true if FNAME is corresponds to a secured file.  Using NULL,
197    "" or "-" for FS is allowed and will return false. This function is
198    used before creating a file, thus it won't fail if the file does
199    not exist. */ 
200 int 
201 is_secured_filename (const char *fname)
202 {
203 #ifdef ENABLE_SELINUX_HACKS
204   struct stat buf;
205   struct secured_file_item *sf;
206
207   if (iobuf_is_pipe_filename (fname) || !*fname)
208     return 0; 
209
210   /* Note that we print out a error here and claim that a file is
211      secure if something went wrong. */
212   if (stat (fname, &buf))
213     {
214       if (errno == ENOENT || errno == EPERM || errno == EACCES)
215         return 0;
216       log_error (_("fstat of `%s' failed in %s: %s\n"), fname,
217                  "is_secured_filename", strerror (errno));
218       return 1;
219     }
220 /*   log_debug ("is_secured_filename (%s) i=%lu.%lu\n", fname, */
221 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
222   for (sf=secured_files; sf; sf = sf->next)
223     {
224       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
225         return 1; /* Yes.  */
226     }
227 #else /*!ENABLE_SELINUX_HACKS*/
228   (void)fname;
229 #endif /*!ENABLE_SELINUX_HACKS*/
230   return 0; /* No. */
231 }
232
233
234
235 u16
236 checksum_u16( unsigned n )
237 {
238     u16 a;
239
240     a  = (n >> 8) & 0xff;
241     a += n & 0xff;
242     return a;
243 }
244
245
246 u16
247 checksum( byte *p, unsigned n )
248 {
249     u16 a;
250
251     for(a=0; n; n-- )
252         a += *p++;
253     return a;
254 }
255
256 u16
257 checksum_mpi (gcry_mpi_t a)
258 {
259   u16 csum;
260   byte *buffer;
261   size_t nbytes;
262
263   if ( gcry_mpi_print (GCRYMPI_FMT_PGP, NULL, 0, &nbytes, a) )
264     BUG ();
265   /* Fixme: For numbers not in secure memory we should use a stack
266    * based buffer and only allocate a larger one if mpi_print returns
267    * an error. */
268   buffer = (gcry_is_secure(a)?
269             gcry_xmalloc_secure (nbytes) : gcry_xmalloc (nbytes));
270   if ( gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes, NULL, a) )
271     BUG ();
272   csum = checksum (buffer, nbytes);
273   xfree (buffer);
274   return csum;
275 }
276
277 u32
278 buffer_to_u32( const byte *buffer )
279 {
280     unsigned long a;
281     a =  *buffer << 24;
282     a |= buffer[1] << 16;
283     a |= buffer[2] << 8;
284     a |= buffer[3];
285     return a;
286 }
287
288 void
289 print_pubkey_algo_note( int algo )
290 {
291   if(algo >= 100 && algo <= 110)
292     {
293       static int warn=0;
294       if(!warn)
295         {
296           warn=1;
297           log_info (_("WARNING: using experimental public key algorithm %s\n"),
298                     openpgp_cipher_algo_name (algo));
299         }
300     }
301   else if (algo == 20)
302     {
303       log_info (_("WARNING: Elgamal sign+encrypt keys are deprecated\n"));
304     }
305 }
306
307 void
308 print_cipher_algo_note( int algo )
309 {
310   if(algo >= 100 && algo <= 110)
311     {
312       static int warn=0;
313       if(!warn)
314         {
315           warn=1;
316           log_info (_("WARNING: using experimental cipher algorithm %s\n"),
317                     openpgp_cipher_algo_name (algo));
318         }
319     }
320 }
321
322 void
323 print_digest_algo_note( int algo )
324 {
325   if(algo >= 100 && algo <= 110)
326     {
327       static int warn=0;
328       if(!warn)
329         {
330           warn=1;
331           log_info (_("WARNING: using experimental digest algorithm %s\n"),
332                     gcry_md_algo_name (algo));
333         }
334     }
335   else if(algo==DIGEST_ALGO_MD5)
336     log_info (_("WARNING: digest algorithm %s is deprecated\n"),
337               gcry_md_algo_name (algo));
338 }
339
340
341 /* Map OpenPGP algo numbers to those used by Libgcrypt.  We need to do
342    this for algorithms we implemented in Libgcrypt after they become
343    part of OpenPGP.  */
344 int
345 map_cipher_openpgp_to_gcry (int algo)
346 {
347   switch (algo)
348     {
349     case CIPHER_ALGO_CAMELLIA128: return 310; 
350     case CIPHER_ALGO_CAMELLIA192: return 311; 
351     case CIPHER_ALGO_CAMELLIA256: return 312; 
352     default: return algo;
353     }
354 }
355
356 /* The inverse fucntion of above.  */
357 static int
358 map_cipher_gcry_to_openpgp (int algo)
359 {
360   switch (algo)
361     {
362     case 310: return CIPHER_ALGO_CAMELLIA128;
363     case 311: return CIPHER_ALGO_CAMELLIA192;
364     case 312: return CIPHER_ALGO_CAMELLIA256;
365     default: return algo;
366     }
367 }
368
369 /* Map OpenPGP public key algorithm numbers to those used by
370    Libgcrypt.  */
371 int
372 map_pk_openpgp_to_gcry (int algo)
373 {
374   switch (algo)
375     {
376     case PUBKEY_ALGO_ECDSA: return GCRY_PK_ECDSA;
377     case PUBKEY_ALGO_ECDH:  return GCRY_PK_ECDH;
378     default: return algo;
379     }
380 }
381
382 /* Map Gcrypt public key algorithm numbers to those used by
383    OpenPGP.  */
384 int
385 map_pk_gcry_to_openpgp (enum gcry_pk_algos algo)
386 {
387   switch (algo)
388     {
389     case GCRY_PK_ECDSA:  return PUBKEY_ALGO_ECDSA;
390     case GCRY_PK_ECDH:   return PUBKEY_ALGO_ECDH;
391     default: return algo < 110 ? algo : 0;
392     }
393 }
394
395
396 /* Return the block length of an OpenPGP cipher algorithm.  */
397 int 
398 openpgp_cipher_blocklen (int algo)
399 {
400   /* We use the numbers from OpenPGP to be sure that we get the right
401      block length.  This is so that the packet parsing code works even
402      for unknown algorithms (for which we assume 8 due to tradition).
403
404      NOTE: If you change the the returned blocklen above 16, check
405      the callers because they may use a fixed size buffer of that
406      size. */
407   switch (algo)
408     {
409     case 7: case 8: case 9: /* AES */
410     case 10: /* Twofish */
411     case 11: case 12: case 13: /* Camellia */
412       return 16;
413
414     default:
415       return 8;
416     }
417 }
418
419 /****************
420  * Wrapper around the libgcrypt function with additonal checks on
421  * the OpenPGP contraints for the algo ID.
422  */
423 int
424 openpgp_cipher_test_algo( int algo )
425 {
426   /* (5 and 6 are marked reserved by rfc4880.)  */
427   if ( algo < 0 || algo > 110 || algo == 5 || algo == 6 )
428     return gpg_error (GPG_ERR_CIPHER_ALGO);
429
430   return gcry_cipher_test_algo (map_cipher_openpgp_to_gcry (algo));
431 }
432
433 /* Map the OpenPGP cipher algorithm whose ID is contained in ALGORITHM to a
434    string representation of the algorithm name.  For unknown algorithm
435    IDs this function returns "?".  */
436 const char *
437 openpgp_cipher_algo_name (int algo) 
438 {
439   return gnupg_cipher_algo_name (map_cipher_openpgp_to_gcry (algo));
440 }
441
442 int
443 openpgp_pk_test_algo( int algo )
444 {
445   /* Dont't allow type 20 keys unless in rfc2440 mode.  */
446   if (!RFC2440 && algo == 20)
447     return gpg_error (GPG_ERR_PUBKEY_ALGO);
448     
449   if (algo == GCRY_PK_ELG_E)
450     algo = GCRY_PK_ELG;
451
452   if (algo < 0 || algo > 110)
453     return gpg_error (GPG_ERR_PUBKEY_ALGO);
454
455   return gcry_pk_test_algo (map_pk_openpgp_to_gcry (algo));
456 }
457
458 int
459 openpgp_pk_test_algo2( int algo, unsigned int use )
460 {
461   size_t use_buf = use;
462
463   /* Dont't allow type 20 keys unless in rfc2440 mode.  */
464   if (!RFC2440 && algo == 20)
465     return gpg_error (GPG_ERR_PUBKEY_ALGO);
466
467   if (algo == GCRY_PK_ELG_E)
468     algo = GCRY_PK_ELG;
469
470   if (algo < 0 || algo > 110)
471     return gpg_error (GPG_ERR_PUBKEY_ALGO);
472
473   return gcry_pk_algo_info (map_pk_openpgp_to_gcry (algo),
474                             GCRYCTL_TEST_ALGO, NULL, &use_buf);
475 }
476
477 int 
478 openpgp_pk_algo_usage ( int algo )
479 {
480     int use = 0; 
481     
482     /* They are hardwired in gpg 1.0. */
483     switch ( algo ) {    
484       case PUBKEY_ALGO_RSA:
485           use = (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG
486                  | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH);
487           break;
488       case PUBKEY_ALGO_RSA_E:
489       case PUBKEY_ALGO_ECDH:
490           use = PUBKEY_USAGE_ENC;
491           break;
492       case PUBKEY_ALGO_RSA_S:
493           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG;
494           break;
495       case PUBKEY_ALGO_ELGAMAL:
496           if (RFC2440)
497              use = PUBKEY_USAGE_ENC;
498           break;
499       case PUBKEY_ALGO_ELGAMAL_E:
500           use = PUBKEY_USAGE_ENC;
501           break;
502       case PUBKEY_ALGO_DSA:  
503           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
504           break;
505       case PUBKEY_ALGO_ECDSA:
506           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
507       default:
508           break;
509     }
510     return use;
511 }
512
513 /* Map the OpenPGP pubkey algorithm whose ID is contained in ALGO to a
514    string representation of the algorithm name.  For unknown algorithm
515    IDs this function returns "?".  */
516 const char *
517 openpgp_pk_algo_name (int algo) 
518 {
519   return gcry_pk_algo_name (map_pk_openpgp_to_gcry (algo));
520 }
521
522
523 int
524 openpgp_md_test_algo( int algo )
525 {
526   /* Note: If the list of actual supported OpenPGP algorithms changes,
527      make sure that our hard coded values at
528      print_status_begin_signing() gets updated. */
529   /* 4, 5, 6, 7 are defined by rfc2440 but will be removed from the
530      next revision of the standard.  */
531   if (algo < 0 || algo > 110 || (algo >= 4 && algo <= 7))
532     return gpg_error (GPG_ERR_DIGEST_ALGO);
533   return gcry_md_test_algo (algo);
534 }
535
536
537 /* Map the OpenPGP digest algorithm whose ID is contained in ALGO to a
538    string representation of the algorithm name.  For unknown algorithm
539    IDs this function returns "?".  */
540 const char *
541 openpgp_md_algo_name (int algo) 
542 {
543   if (algo < 0 || algo > 110)
544     return "?";
545   return gcry_md_algo_name (algo);
546 }
547
548
549 #ifdef USE_IDEA
550 /* Special warning for the IDEA cipher */
551 void
552 idea_cipher_warn(int show)
553 {
554   static int warned=0;
555
556   if(!warned || show)
557     {
558       log_info(_("the IDEA cipher plugin is not present\n"));
559       log_info(_("please see %s for more information\n"),
560                "http://www.gnupg.org/faq/why-not-idea.html");
561       warned=1;
562     }
563 }
564 #endif
565
566
567 static unsigned long 
568 get_signature_count (PKT_public_key *pk)
569 {
570 #ifdef ENABLE_CARD_SUPPORT
571   struct agent_card_info_s info;
572 #warning fixme: We should check that the correct card has been inserted
573   if (!agent_scd_getattr ("SIG-COUNTER",&info))
574     return info.sig_counter;
575   else
576     return 0;
577 #else
578   (void)pk;
579   return 0;
580 #endif
581 }
582
583 /* Expand %-strings.  Returns a string which must be xfreed.  Returns
584    NULL if the string cannot be expanded (too large). */
585 char *
586 pct_expando(const char *string,struct expando_args *args)
587 {
588   const char *ch=string;
589   int idx=0,maxlen=0,done=0;
590   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
591   char *ret=NULL;
592
593   if(args->pk)
594     keyid_from_pk(args->pk,pk_keyid);
595
596   if(args->pksk)
597     keyid_from_pk (args->pksk, sk_keyid);
598
599   /* This is used so that %k works in photoid command strings in
600      --list-secret-keys (which of course has a sk, but no pk). */
601   if(!args->pk && args->pksk)
602     keyid_from_pk (args->pksk, pk_keyid);
603
604   while(*ch!='\0')
605     {
606       if(!done)
607         {
608           /* 8192 is way bigger than we'll need here */
609           if(maxlen>=8192)
610             goto fail;
611
612           maxlen+=1024;
613           ret=xrealloc(ret,maxlen);
614         }
615
616       done=0;
617
618       if(*ch=='%')
619         {
620           switch(*(ch+1))
621             {
622             case 's': /* short key id */
623               if(idx+8<maxlen)
624                 {
625                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
626                   idx+=8;
627                   done=1;
628                 }
629               break;
630
631             case 'S': /* long key id */
632               if(idx+16<maxlen)
633                 {
634                   sprintf(&ret[idx],"%08lX%08lX",
635                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
636                   idx+=16;
637                   done=1;
638                 }
639               break;
640
641             case 'k': /* short key id */
642               if(idx+8<maxlen)
643                 {
644                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
645                   idx+=8;
646                   done=1;
647                 }
648               break;
649
650             case 'K': /* long key id */
651               if(idx+16<maxlen)
652                 {
653                   sprintf(&ret[idx],"%08lX%08lX",
654                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
655                   idx+=16;
656                   done=1;
657                 }
658               break;
659
660             case 'c': /* signature count from card, if any. */
661               if(idx+10<maxlen)
662                 {
663                   sprintf (&ret[idx],"%lu", get_signature_count (args->pksk));
664                   idx+=strlen(&ret[idx]);
665                   done=1;
666                 }             
667               break;
668
669             case 'p': /* primary pk fingerprint of a sk */
670             case 'f': /* pk fingerprint */
671             case 'g': /* sk fingerprint */
672               {
673                 byte array[MAX_FINGERPRINT_LEN];
674                 size_t len;
675                 int i;
676
677                 if((*(ch+1))=='p' && args->pksk)
678                   {
679                     if(args->pksk->flags.primary)
680                       fingerprint_from_pk (args->pksk, array, &len);
681                     else if (args->pksk->main_keyid[0]
682                              || args->pksk->main_keyid[1])
683                       {
684                         /* FIXME: Document teh code and check whether
685                            it is still needed.  */
686                         PKT_public_key *pk=
687                           xmalloc_clear(sizeof(PKT_public_key));
688
689                         if (!get_pubkey_fast (pk,args->pksk->main_keyid))
690                           fingerprint_from_pk (pk, array, &len);
691                         else
692                           memset (array, 0, (len=MAX_FINGERPRINT_LEN));
693                         free_public_key (pk);
694                       }
695                     else
696                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
697                   }
698                 else if((*(ch+1))=='f' && args->pk)
699                   fingerprint_from_pk (args->pk, array, &len);
700                 else if((*(ch+1))=='g' && args->pksk)
701                   fingerprint_from_pk (args->pksk, array, &len);
702                 else
703                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
704
705                 if(idx+(len*2)<maxlen)
706                   {
707                     for(i=0;i<len;i++)
708                       {
709                         sprintf(&ret[idx],"%02X",array[i]);
710                         idx+=2;
711                       }
712                     done=1;
713                   }
714               }
715               break;
716
717             case 'v': /* validity letters */
718               if(args->validity_info && idx+1<maxlen)
719                 {
720                   ret[idx++]=args->validity_info;
721                   ret[idx]='\0';
722                   done=1;
723                 }
724               break;
725
726               /* The text string types */
727             case 't':
728             case 'T':
729             case 'V':
730               {
731                 const char *str=NULL;
732
733                 switch(*(ch+1))
734                   {
735                   case 't': /* e.g. "jpg" */
736                     str=image_type_to_string(args->imagetype,0);
737                     break;
738                   
739                   case 'T': /* e.g. "image/jpeg" */
740                     str=image_type_to_string(args->imagetype,2);
741                     break;
742
743                   case 'V': /* e.g. "full", "expired", etc. */
744                     str=args->validity_string;
745                     break;
746                   }
747
748                 if(str && idx+strlen(str)<maxlen)
749                   {
750                     strcpy(&ret[idx],str);
751                     idx+=strlen(str);
752                     done=1;
753                   }
754               }
755               break;
756
757             case '%':
758               if(idx+1<maxlen)
759                 {
760                   ret[idx++]='%';
761                   ret[idx]='\0';
762                   done=1;
763                 }
764               break;
765
766               /* Any unknown %-keys (like %i, %o, %I, and %O) are
767                  passed through for later expansion.  Note this also
768                  handles the case where the last character in the
769                  string is a '%' - the terminating \0 will end up here
770                  and properly terminate the string. */
771             default:
772               if(idx+2<maxlen)
773                 {
774                   ret[idx++]='%';
775                   ret[idx++]=*(ch+1);
776                   ret[idx]='\0';
777                   done=1;
778                 }
779               break;
780               }
781
782           if(done)
783             ch++;
784         }
785       else
786         {
787           if(idx+1<maxlen)
788             {
789               ret[idx++]=*ch;
790               ret[idx]='\0';
791               done=1;
792             }
793         }
794
795       if(done)
796         ch++;
797     }
798
799   return ret;
800
801  fail:
802   xfree(ret);
803   return NULL;
804 }
805
806 void
807 deprecated_warning(const char *configname,unsigned int configlineno,
808                    const char *option,const char *repl1,const char *repl2)
809 {
810   if(configname)
811     {
812       if(strncmp("--",option,2)==0)
813         option+=2;
814
815       if(strncmp("--",repl1,2)==0)
816         repl1+=2;
817
818       log_info(_("%s:%d: deprecated option \"%s\"\n"),
819                configname,configlineno,option);
820     }
821   else
822     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
823
824   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
825 }
826
827
828 void
829 deprecated_command (const char *name)
830 {
831   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
832            name);
833 }
834
835
836 void
837 obsolete_option (const char *configname, unsigned int configlineno, 
838                  const char *name)
839 {
840   if(configname)
841     log_info (_("%s:%u: obsolete option \"%s\" - it has no effect\n"),
842               configname, configlineno, name);
843   else
844     log_info (_("WARNING: \"%s\" is an obsolete option - it has no effect\n"),
845               name);
846 }
847
848
849 /*
850  * Wrapper around gcry_cipher_map_name to provide a fallback using the
851  * "Sn" syntax as used by the preference strings.
852  */
853 int 
854 string_to_cipher_algo (const char *string) 
855
856   int val;
857
858   val = map_cipher_gcry_to_openpgp (gcry_cipher_map_name (string));
859   if (!val && string && (string[0]=='S' || string[0]=='s'))
860     {
861       char *endptr;
862
863       string++;
864       val = strtol (string, &endptr, 10);
865       if (!*string || *endptr || openpgp_cipher_test_algo (val))
866         val = 0;
867     }
868
869   return val;
870 }
871
872 /*
873  * Wrapper around gcry_md_map_name to provide a fallback using the
874  * "Hn" syntax as used by the preference strings.
875  */
876 int 
877 string_to_digest_algo (const char *string) 
878
879   int val;
880
881   val = gcry_md_map_name (string);
882   if (!val && string && (string[0]=='H' || string[0]=='h'))
883     {
884       char *endptr;
885
886       string++;
887       val = strtol (string, &endptr, 10);
888       if (!*string || *endptr || openpgp_md_test_algo (val))
889         val = 0;
890     }
891
892   return val;
893 }
894
895
896
897 const char *
898 compress_algo_to_string(int algo)
899 {
900   const char *s=NULL;
901
902   switch(algo)
903     {
904     case COMPRESS_ALGO_NONE:
905       s=_("Uncompressed");
906       break;
907
908     case COMPRESS_ALGO_ZIP:
909       s="ZIP";
910       break;
911
912     case COMPRESS_ALGO_ZLIB:
913       s="ZLIB";
914       break;
915
916 #ifdef HAVE_BZIP2
917     case COMPRESS_ALGO_BZIP2:
918       s="BZIP2";
919       break;
920 #endif
921     }
922
923   return s;
924 }
925
926 int
927 string_to_compress_algo(const char *string)
928 {
929   /* TRANSLATORS: See doc/TRANSLATE about this string. */
930   if(match_multistr(_("uncompressed|none"),string))
931     return 0;
932   else if(ascii_strcasecmp(string,"uncompressed")==0)
933     return 0;
934   else if(ascii_strcasecmp(string,"none")==0)
935     return 0;
936   else if(ascii_strcasecmp(string,"zip")==0)
937     return 1;
938   else if(ascii_strcasecmp(string,"zlib")==0)
939     return 2;
940 #ifdef HAVE_BZIP2
941   else if(ascii_strcasecmp(string,"bzip2")==0)
942     return 3;
943 #endif
944   else if(ascii_strcasecmp(string,"z0")==0)
945     return 0;
946   else if(ascii_strcasecmp(string,"z1")==0)
947     return 1;
948   else if(ascii_strcasecmp(string,"z2")==0)
949     return 2;
950 #ifdef HAVE_BZIP2
951   else if(ascii_strcasecmp(string,"z3")==0)
952     return 3;
953 #endif
954   else
955     return -1;
956 }
957
958 int
959 check_compress_algo(int algo)
960 {
961   switch (algo)
962     {
963     case 0: return 0;
964 #ifdef HAVE_ZIP
965     case 1:  
966     case 2: return 0;
967 #endif
968 #ifdef HAVE_BZIP2
969     case 3: return 0;
970 #endif
971     default: return G10ERR_COMPR_ALGO;
972     }
973 }
974
975 int
976 default_cipher_algo(void)
977 {
978   if(opt.def_cipher_algo)
979     return opt.def_cipher_algo;
980   else if(opt.personal_cipher_prefs)
981     return opt.personal_cipher_prefs[0].value;
982   else
983     return opt.s2k_cipher_algo;
984 }
985
986 /* There is no default_digest_algo function, but see
987    sign.c:hash_for() */
988
989 int
990 default_compress_algo(void)
991 {
992   if(opt.compress_algo!=-1)
993     return opt.compress_algo;
994   else if(opt.personal_compress_prefs)
995     return opt.personal_compress_prefs[0].value;
996   else
997     return DEFAULT_COMPRESS_ALGO;
998 }
999
1000 const char *
1001 compliance_option_string(void)
1002 {
1003   char *ver="???";
1004
1005   switch(opt.compliance)
1006     {
1007     case CO_GNUPG:   return "--gnupg";
1008     case CO_RFC4880: return "--openpgp";
1009     case CO_RFC2440: return "--rfc2440";
1010     case CO_RFC1991: return "--rfc1991";
1011     case CO_PGP2:    return "--pgp2";
1012     case CO_PGP6:    return "--pgp6";
1013     case CO_PGP7:    return "--pgp7";
1014     case CO_PGP8:    return "--pgp8";
1015     }
1016
1017   return ver;
1018 }
1019
1020 void
1021 compliance_failure(void)
1022 {
1023   char *ver="???";
1024
1025   switch(opt.compliance)
1026     {
1027     case CO_GNUPG:
1028       ver="GnuPG";
1029       break;
1030
1031     case CO_RFC4880:
1032       ver="OpenPGP";
1033       break;
1034
1035     case CO_RFC2440:
1036       ver="OpenPGP (older)";
1037       break;
1038
1039     case CO_RFC1991:
1040       ver="old PGP";
1041       break;
1042
1043     case CO_PGP2:
1044       ver="PGP 2.x";
1045       break;
1046
1047     case CO_PGP6:
1048       ver="PGP 6.x";
1049       break;
1050
1051     case CO_PGP7:
1052       ver="PGP 7.x";
1053       break;
1054
1055     case CO_PGP8:
1056       ver="PGP 8.x";
1057       break;
1058     }
1059
1060   log_info(_("this message may not be usable by %s\n"),ver);
1061   opt.compliance=CO_GNUPG;
1062 }
1063
1064 /* Break a string into successive option pieces.  Accepts single word
1065    options and key=value argument options. */
1066 char *
1067 optsep(char **stringp)
1068 {
1069   char *tok,*end;
1070
1071   tok=*stringp;
1072   if(tok)
1073     {
1074       end=strpbrk(tok," ,=");
1075       if(end)
1076         {
1077           int sawequals=0;
1078           char *ptr=end;
1079
1080           /* what we need to do now is scan along starting with *end,
1081              If the next character we see (ignoring spaces) is an =
1082              sign, then there is an argument. */
1083
1084           while(*ptr)
1085             {
1086               if(*ptr=='=')
1087                 sawequals=1;
1088               else if(*ptr!=' ')
1089                 break;
1090               ptr++;
1091             }
1092
1093           /* There is an argument, so grab that too.  At this point,
1094              ptr points to the first character of the argument. */
1095           if(sawequals)
1096             {
1097               /* Is it a quoted argument? */
1098               if(*ptr=='"')
1099                 {
1100                   ptr++;
1101                   end=strchr(ptr,'"');
1102                   if(end)
1103                     end++;
1104                 }
1105               else
1106                 end=strpbrk(ptr," ,");
1107             }
1108
1109           if(end && *end)
1110             {
1111               *end='\0';
1112               *stringp=end+1;
1113             }
1114           else
1115             *stringp=NULL;
1116         }
1117       else
1118         *stringp=NULL;
1119     }
1120
1121   return tok;
1122 }
1123
1124 /* Breaks an option value into key and value.  Returns NULL if there
1125    is no value.  Note that "string" is modified to remove the =value
1126    part. */
1127 char *
1128 argsplit(char *string)
1129 {
1130   char *equals,*arg=NULL;
1131
1132   equals=strchr(string,'=');
1133   if(equals)
1134     {
1135       char *quote,*space;
1136
1137       *equals='\0';
1138       arg=equals+1;
1139
1140       /* Quoted arg? */
1141       quote=strchr(arg,'"');
1142       if(quote)
1143         {
1144           arg=quote+1;
1145
1146           quote=strchr(arg,'"');
1147           if(quote)
1148             *quote='\0';
1149         }
1150       else
1151         {
1152           size_t spaces;
1153
1154           /* Trim leading spaces off of the arg */
1155           spaces=strspn(arg," ");
1156           arg+=spaces;
1157         }
1158
1159       /* Trim tailing spaces off of the tag */
1160       space=strchr(string,' ');
1161       if(space)
1162         *space='\0';
1163     }
1164
1165   return arg;
1166 }
1167
1168 /* Return the length of the initial token, leaving off any
1169    argument. */
1170 static size_t
1171 optlen(const char *s)
1172 {
1173   char *end=strpbrk(s," =");
1174
1175   if(end)
1176     return end-s;
1177   else
1178     return strlen(s);
1179 }
1180
1181 int
1182 parse_options(char *str,unsigned int *options,
1183               struct parse_options *opts,int noisy)
1184 {
1185   char *tok;
1186
1187   if (str && !strcmp (str, "help"))
1188     {
1189       int i,maxlen=0;
1190
1191       /* Figure out the longest option name so we can line these up
1192          neatly. */
1193       for(i=0;opts[i].name;i++)
1194         if(opts[i].help && maxlen<strlen(opts[i].name))
1195           maxlen=strlen(opts[i].name);
1196
1197       for(i=0;opts[i].name;i++)
1198         if(opts[i].help)
1199           printf("%s%*s%s\n",opts[i].name,
1200                  maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1201
1202       g10_exit(0);
1203     }
1204
1205   while((tok=optsep(&str)))
1206     {
1207       int i,rev=0;
1208       char *otok=tok;
1209
1210       if(tok[0]=='\0')
1211         continue;
1212
1213       if(ascii_strncasecmp("no-",tok,3)==0)
1214         {
1215           rev=1;
1216           tok+=3;
1217         }
1218
1219       for(i=0;opts[i].name;i++)
1220         {
1221           size_t toklen=optlen(tok);
1222
1223           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1224             {
1225               /* We have a match, but it might be incomplete */
1226               if(toklen!=strlen(opts[i].name))
1227                 {
1228                   int j;
1229
1230                   for(j=i+1;opts[j].name;j++)
1231                     {
1232                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1233                         {
1234                           if(noisy)
1235                             log_info(_("ambiguous option `%s'\n"),otok);
1236                           return 0;
1237                         }
1238                     }
1239                 }
1240
1241               if(rev)
1242                 {
1243                   *options&=~opts[i].bit;
1244                   if(opts[i].value)
1245                     *opts[i].value=NULL;
1246                 }
1247               else
1248                 {
1249                   *options|=opts[i].bit;
1250                   if(opts[i].value)
1251                     *opts[i].value=argsplit(tok);
1252                 }
1253               break;
1254             }
1255         }
1256
1257       if(!opts[i].name)
1258         {
1259           if(noisy)
1260             log_info(_("unknown option `%s'\n"),otok);
1261           return 0;
1262         }
1263     }
1264
1265   return 1;
1266 }
1267
1268
1269 /* Check whether the string has characters not valid in an RFC-822
1270    address.  To cope with OpenPGP we ignore non-ascii characters
1271    so that for example umlauts are legal in an email address.  An
1272    OpenPGP user ID must be utf-8 encoded but there is no strict
1273    requirement for RFC-822.  Thus to avoid IDNA encoding we put the
1274    address verbatim as utf-8 into the user ID under the assumption
1275    that mail programs handle IDNA at a lower level and take OpenPGP
1276    user IDs as utf-8.  Note that we can't do an utf-8 encoding
1277    checking here because in keygen.c this function is called with the
1278    native encoding and native to utf-8 encoding is only done  later.  */
1279 int
1280 has_invalid_email_chars (const char *s)
1281 {
1282   int at_seen=0;
1283   const char *valid_chars=
1284     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1285
1286   for ( ; *s; s++ ) 
1287     {
1288       if ( (*s & 0x80) )
1289         continue; /* We only care about ASCII.  */
1290       if ( *s == '@' )
1291         at_seen=1;
1292       else if ( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1293         return 1;
1294       else if ( at_seen && !strchr( valid_chars, *s ) )
1295         return 1;
1296     }
1297   return 0;
1298 }
1299
1300
1301 /* Check whether NAME represents a valid mailbox according to
1302    RFC822. Returns true if so. */
1303 int
1304 is_valid_mailbox (const char *name)
1305 {
1306   return !( !name
1307             || !*name
1308             || has_invalid_email_chars (name)
1309             || string_count_chr (name,'@') != 1
1310             || *name == '@'
1311             || name[strlen(name)-1] == '@'
1312             || name[strlen(name)-1] == '.'
1313             || strstr (name, "..") );
1314 }
1315
1316
1317 /* Similar to access(2), but uses PATH to find the file. */
1318 int
1319 path_access(const char *file,int mode)
1320 {
1321   char *envpath;
1322   int ret=-1;
1323
1324   envpath=getenv("PATH");
1325
1326   if(!envpath
1327 #ifdef HAVE_DRIVE_LETTERS
1328      || (((file[0]>='A' && file[0]<='Z')
1329           || (file[0]>='a' && file[0]<='z'))
1330          && file[1]==':')
1331 #else
1332      || file[0]=='/'
1333 #endif
1334      )
1335     return access(file,mode);
1336   else
1337     {
1338       /* At least as large as, but most often larger than we need. */
1339       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1340       char *split,*item,*path=xstrdup(envpath);
1341
1342       split=path;
1343
1344       while((item=strsep(&split,PATHSEP_S)))
1345         {
1346           strcpy(buffer,item);
1347           strcat(buffer,"/");
1348           strcat(buffer,file);
1349           ret=access(buffer,mode);
1350           if(ret==0)
1351             break;
1352         }
1353
1354       xfree(path);
1355       xfree(buffer);
1356     }
1357
1358   return ret;
1359 }
1360
1361
1362 \f
1363 /* Return the number of public key parameters as used by OpenPGP.  */
1364 int
1365 pubkey_get_npkey (int algo)
1366 {
1367   size_t n;
1368
1369   /* ECC is special.  */
1370   if (algo == PUBKEY_ALGO_ECDSA)
1371     return 2;
1372   else if (algo == PUBKEY_ALGO_ECDH)
1373     return 3;
1374
1375   /* All other algorithms match those of Libgcrypt.  */
1376   if (algo == GCRY_PK_ELG_E)
1377     algo = GCRY_PK_ELG;
1378
1379   if (gcry_pk_algo_info (algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &n))
1380     n = 0;
1381   return n;
1382 }
1383
1384
1385 /* Return the number of secret key parameters as used by OpenPGP.  */
1386 int
1387 pubkey_get_nskey (int algo)
1388 {
1389   size_t n;
1390
1391   /* ECC is special.  */
1392   if (algo == PUBKEY_ALGO_ECDSA)
1393     return 3;
1394   else if (algo == PUBKEY_ALGO_ECDH)
1395     return 4;
1396
1397   /* All other algorithms match those of Libgcrypt.  */
1398   if (algo == GCRY_PK_ELG_E)
1399     algo = GCRY_PK_ELG;
1400
1401   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &n ))
1402     n = 0;
1403   return n;
1404 }
1405
1406 /* Temporary helper. */
1407 int
1408 pubkey_get_nsig (int algo)
1409 {
1410   size_t n;
1411
1412   /* ECC is special.  */
1413   if (algo == PUBKEY_ALGO_ECDSA)
1414     return 2;
1415   else if (algo == PUBKEY_ALGO_ECDH)
1416     return 0;
1417
1418   if (algo == GCRY_PK_ELG_E)
1419     algo = GCRY_PK_ELG;
1420
1421   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSIGN, NULL, &n))
1422     n = 0;
1423   return n;
1424 }
1425
1426
1427 /* Temporary helper. */
1428 int
1429 pubkey_get_nenc (int algo)
1430 {
1431   size_t n;
1432   
1433   /* ECC is special.  */
1434   if (algo == PUBKEY_ALGO_ECDSA)
1435     return 0;
1436   else if (algo == PUBKEY_ALGO_ECDH)
1437     return 2;
1438
1439   if (algo == GCRY_PK_ELG_E)
1440     algo = GCRY_PK_ELG;
1441
1442   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NENCR, NULL, &n ))
1443     n = 0;
1444   return n;
1445 }
1446
1447
1448 /* Temporary helper. */
1449 unsigned int
1450 pubkey_nbits( int algo, gcry_mpi_t *key )
1451 {
1452     int rc, nbits;
1453     gcry_sexp_t sexp;
1454
1455 #warning FIXME:  We are mixing OpenPGP And CGrypt Ids
1456     assert( algo != GCRY_PK_ECDSA && algo != GCRY_PK_ECDH );
1457
1458     if( algo == GCRY_PK_DSA ) {
1459         rc = gcry_sexp_build ( &sexp, NULL,
1460                               "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1461                                   key[0], key[1], key[2], key[3] );
1462     }
1463     else if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E ) {
1464         rc = gcry_sexp_build ( &sexp, NULL,
1465                               "(public-key(elg(p%m)(g%m)(y%m)))",
1466                                   key[0], key[1], key[2] );
1467     }
1468     else if( algo == GCRY_PK_RSA ) {
1469         rc = gcry_sexp_build ( &sexp, NULL,
1470                               "(public-key(rsa(n%m)(e%m)))",
1471                                   key[0], key[1] );
1472     }
1473     else if( algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_ECDH ) {
1474         char *curve = openpgp_oid_to_str (key[0]);
1475         if (!curve)
1476           rc = gpg_error_from_syserror ();
1477         else
1478           {
1479             rc = gcry_sexp_build (&sexp, NULL,
1480                                   "(public-key(ecc(curve%s)(q%m)))",
1481                                   curve, key[1]);
1482             xfree (curve);
1483           }
1484     }
1485     else
1486         return 0;
1487
1488     if ( rc )
1489         BUG ();
1490
1491     nbits = gcry_pk_get_nbits( sexp );
1492     gcry_sexp_release( sexp );
1493     return nbits;
1494 }
1495
1496
1497
1498 int
1499 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1500 {
1501   int n=0;
1502   
1503   if (!a)
1504     return es_fprintf (fp, "[MPI_NULL]");
1505   if (!mode)
1506     {
1507       unsigned int n1;
1508       n1 = gcry_mpi_get_nbits(a);
1509       n += es_fprintf (fp, "[%u bits]", n1);
1510     }
1511   else if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
1512     {
1513       unsigned int nbits;
1514       unsigned char *p = gcry_mpi_get_opaque (a, &nbits);
1515       if (!p)
1516         n += es_fprintf (fp, "[invalid opaque value]");
1517       else
1518         {
1519           nbits = (nbits + 7)/8;
1520           for (; nbits; nbits--, p++)
1521             n += es_fprintf (fp, "%02X", *p);
1522         }
1523     }
1524   else
1525     {
1526       unsigned char *buffer;
1527       
1528       if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a))
1529         BUG ();
1530       es_fputs (buffer, fp);
1531       n += strlen (buffer);
1532       gcry_free (buffer);
1533     }
1534   return n;
1535 }
1536
1537
1538 /* pkey[1] or skey[1] is Q for ECDSA, which is an uncompressed point,
1539    i.e.  04 <x> <y> */
1540 unsigned int 
1541 ecdsa_qbits_from_Q (unsigned int qbits)
1542 {
1543   if ((qbits%8) > 3)
1544     {
1545       log_error (_("ECDSA public key is expected to be in SEC encoding "
1546                    "multiple of 8 bits\n"));
1547       return 0;
1548     }
1549   qbits -= qbits%8;
1550   qbits /= 2;
1551   return qbits;
1552 }
1553
1554