Don't print anonymous recipient messages in quiet mode.
[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
573   (void)pk;
574   if (!agent_scd_getattr ("SIG-COUNTER",&info))
575     return info.sig_counter;
576   else
577     return 0;
578 #else
579   (void)pk;
580   return 0;
581 #endif
582 }
583
584 /* Expand %-strings.  Returns a string which must be xfreed.  Returns
585    NULL if the string cannot be expanded (too large). */
586 char *
587 pct_expando(const char *string,struct expando_args *args)
588 {
589   const char *ch=string;
590   int idx=0,maxlen=0,done=0;
591   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
592   char *ret=NULL;
593
594   if(args->pk)
595     keyid_from_pk(args->pk,pk_keyid);
596
597   if(args->pksk)
598     keyid_from_pk (args->pksk, sk_keyid);
599
600   /* This is used so that %k works in photoid command strings in
601      --list-secret-keys (which of course has a sk, but no pk). */
602   if(!args->pk && args->pksk)
603     keyid_from_pk (args->pksk, pk_keyid);
604
605   while(*ch!='\0')
606     {
607       if(!done)
608         {
609           /* 8192 is way bigger than we'll need here */
610           if(maxlen>=8192)
611             goto fail;
612
613           maxlen+=1024;
614           ret=xrealloc(ret,maxlen);
615         }
616
617       done=0;
618
619       if(*ch=='%')
620         {
621           switch(*(ch+1))
622             {
623             case 's': /* short key id */
624               if(idx+8<maxlen)
625                 {
626                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
627                   idx+=8;
628                   done=1;
629                 }
630               break;
631
632             case 'S': /* long key id */
633               if(idx+16<maxlen)
634                 {
635                   sprintf(&ret[idx],"%08lX%08lX",
636                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
637                   idx+=16;
638                   done=1;
639                 }
640               break;
641
642             case 'k': /* short key id */
643               if(idx+8<maxlen)
644                 {
645                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
646                   idx+=8;
647                   done=1;
648                 }
649               break;
650
651             case 'K': /* long key id */
652               if(idx+16<maxlen)
653                 {
654                   sprintf(&ret[idx],"%08lX%08lX",
655                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
656                   idx+=16;
657                   done=1;
658                 }
659               break;
660
661             case 'c': /* signature count from card, if any. */
662               if(idx+10<maxlen)
663                 {
664                   sprintf (&ret[idx],"%lu", get_signature_count (args->pksk));
665                   idx+=strlen(&ret[idx]);
666                   done=1;
667                 }
668               break;
669
670             case 'p': /* primary pk fingerprint of a sk */
671             case 'f': /* pk fingerprint */
672             case 'g': /* sk fingerprint */
673               {
674                 byte array[MAX_FINGERPRINT_LEN];
675                 size_t len;
676                 int i;
677
678                 if((*(ch+1))=='p' && args->pksk)
679                   {
680                     if(args->pksk->flags.primary)
681                       fingerprint_from_pk (args->pksk, array, &len);
682                     else if (args->pksk->main_keyid[0]
683                              || args->pksk->main_keyid[1])
684                       {
685                         /* FIXME: Document teh code and check whether
686                            it is still needed.  */
687                         PKT_public_key *pk=
688                           xmalloc_clear(sizeof(PKT_public_key));
689
690                         if (!get_pubkey_fast (pk,args->pksk->main_keyid))
691                           fingerprint_from_pk (pk, array, &len);
692                         else
693                           memset (array, 0, (len=MAX_FINGERPRINT_LEN));
694                         free_public_key (pk);
695                       }
696                     else
697                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
698                   }
699                 else if((*(ch+1))=='f' && args->pk)
700                   fingerprint_from_pk (args->pk, array, &len);
701                 else if((*(ch+1))=='g' && args->pksk)
702                   fingerprint_from_pk (args->pksk, array, &len);
703                 else
704                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
705
706                 if(idx+(len*2)<maxlen)
707                   {
708                     for(i=0;i<len;i++)
709                       {
710                         sprintf(&ret[idx],"%02X",array[i]);
711                         idx+=2;
712                       }
713                     done=1;
714                   }
715               }
716               break;
717
718             case 'v': /* validity letters */
719               if(args->validity_info && idx+1<maxlen)
720                 {
721                   ret[idx++]=args->validity_info;
722                   ret[idx]='\0';
723                   done=1;
724                 }
725               break;
726
727               /* The text string types */
728             case 't':
729             case 'T':
730             case 'V':
731               {
732                 const char *str=NULL;
733
734                 switch(*(ch+1))
735                   {
736                   case 't': /* e.g. "jpg" */
737                     str=image_type_to_string(args->imagetype,0);
738                     break;
739
740                   case 'T': /* e.g. "image/jpeg" */
741                     str=image_type_to_string(args->imagetype,2);
742                     break;
743
744                   case 'V': /* e.g. "full", "expired", etc. */
745                     str=args->validity_string;
746                     break;
747                   }
748
749                 if(str && idx+strlen(str)<maxlen)
750                   {
751                     strcpy(&ret[idx],str);
752                     idx+=strlen(str);
753                     done=1;
754                   }
755               }
756               break;
757
758             case '%':
759               if(idx+1<maxlen)
760                 {
761                   ret[idx++]='%';
762                   ret[idx]='\0';
763                   done=1;
764                 }
765               break;
766
767               /* Any unknown %-keys (like %i, %o, %I, and %O) are
768                  passed through for later expansion.  Note this also
769                  handles the case where the last character in the
770                  string is a '%' - the terminating \0 will end up here
771                  and properly terminate the string. */
772             default:
773               if(idx+2<maxlen)
774                 {
775                   ret[idx++]='%';
776                   ret[idx++]=*(ch+1);
777                   ret[idx]='\0';
778                   done=1;
779                 }
780               break;
781               }
782
783           if(done)
784             ch++;
785         }
786       else
787         {
788           if(idx+1<maxlen)
789             {
790               ret[idx++]=*ch;
791               ret[idx]='\0';
792               done=1;
793             }
794         }
795
796       if(done)
797         ch++;
798     }
799
800   return ret;
801
802  fail:
803   xfree(ret);
804   return NULL;
805 }
806
807 void
808 deprecated_warning(const char *configname,unsigned int configlineno,
809                    const char *option,const char *repl1,const char *repl2)
810 {
811   if(configname)
812     {
813       if(strncmp("--",option,2)==0)
814         option+=2;
815
816       if(strncmp("--",repl1,2)==0)
817         repl1+=2;
818
819       log_info(_("%s:%d: deprecated option \"%s\"\n"),
820                configname,configlineno,option);
821     }
822   else
823     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
824
825   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
826 }
827
828
829 void
830 deprecated_command (const char *name)
831 {
832   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
833            name);
834 }
835
836
837 void
838 obsolete_option (const char *configname, unsigned int configlineno,
839                  const char *name)
840 {
841   if(configname)
842     log_info (_("%s:%u: obsolete option \"%s\" - it has no effect\n"),
843               configname, configlineno, name);
844   else
845     log_info (_("WARNING: \"%s\" is an obsolete option - it has no effect\n"),
846               name);
847 }
848
849
850 /*
851  * Wrapper around gcry_cipher_map_name to provide a fallback using the
852  * "Sn" syntax as used by the preference strings.
853  */
854 int
855 string_to_cipher_algo (const char *string)
856 {
857   int val;
858
859   val = map_cipher_gcry_to_openpgp (gcry_cipher_map_name (string));
860   if (!val && string && (string[0]=='S' || string[0]=='s'))
861     {
862       char *endptr;
863
864       string++;
865       val = strtol (string, &endptr, 10);
866       if (!*string || *endptr || openpgp_cipher_test_algo (val))
867         val = 0;
868     }
869
870   return val;
871 }
872
873 /*
874  * Wrapper around gcry_md_map_name to provide a fallback using the
875  * "Hn" syntax as used by the preference strings.
876  */
877 int
878 string_to_digest_algo (const char *string)
879 {
880   int val;
881
882   val = gcry_md_map_name (string);
883   if (!val && string && (string[0]=='H' || string[0]=='h'))
884     {
885       char *endptr;
886
887       string++;
888       val = strtol (string, &endptr, 10);
889       if (!*string || *endptr || openpgp_md_test_algo (val))
890         val = 0;
891     }
892
893   return val;
894 }
895
896
897
898 const char *
899 compress_algo_to_string(int algo)
900 {
901   const char *s=NULL;
902
903   switch(algo)
904     {
905     case COMPRESS_ALGO_NONE:
906       s=_("Uncompressed");
907       break;
908
909     case COMPRESS_ALGO_ZIP:
910       s="ZIP";
911       break;
912
913     case COMPRESS_ALGO_ZLIB:
914       s="ZLIB";
915       break;
916
917 #ifdef HAVE_BZIP2
918     case COMPRESS_ALGO_BZIP2:
919       s="BZIP2";
920       break;
921 #endif
922     }
923
924   return s;
925 }
926
927 int
928 string_to_compress_algo(const char *string)
929 {
930   /* TRANSLATORS: See doc/TRANSLATE about this string. */
931   if(match_multistr(_("uncompressed|none"),string))
932     return 0;
933   else if(ascii_strcasecmp(string,"uncompressed")==0)
934     return 0;
935   else if(ascii_strcasecmp(string,"none")==0)
936     return 0;
937   else if(ascii_strcasecmp(string,"zip")==0)
938     return 1;
939   else if(ascii_strcasecmp(string,"zlib")==0)
940     return 2;
941 #ifdef HAVE_BZIP2
942   else if(ascii_strcasecmp(string,"bzip2")==0)
943     return 3;
944 #endif
945   else if(ascii_strcasecmp(string,"z0")==0)
946     return 0;
947   else if(ascii_strcasecmp(string,"z1")==0)
948     return 1;
949   else if(ascii_strcasecmp(string,"z2")==0)
950     return 2;
951 #ifdef HAVE_BZIP2
952   else if(ascii_strcasecmp(string,"z3")==0)
953     return 3;
954 #endif
955   else
956     return -1;
957 }
958
959 int
960 check_compress_algo(int algo)
961 {
962   switch (algo)
963     {
964     case 0: return 0;
965 #ifdef HAVE_ZIP
966     case 1:
967     case 2: return 0;
968 #endif
969 #ifdef HAVE_BZIP2
970     case 3: return 0;
971 #endif
972     default: return G10ERR_COMPR_ALGO;
973     }
974 }
975
976 int
977 default_cipher_algo(void)
978 {
979   if(opt.def_cipher_algo)
980     return opt.def_cipher_algo;
981   else if(opt.personal_cipher_prefs)
982     return opt.personal_cipher_prefs[0].value;
983   else
984     return opt.s2k_cipher_algo;
985 }
986
987 /* There is no default_digest_algo function, but see
988    sign.c:hash_for() */
989
990 int
991 default_compress_algo(void)
992 {
993   if(opt.compress_algo!=-1)
994     return opt.compress_algo;
995   else if(opt.personal_compress_prefs)
996     return opt.personal_compress_prefs[0].value;
997   else
998     return DEFAULT_COMPRESS_ALGO;
999 }
1000
1001 const char *
1002 compliance_option_string(void)
1003 {
1004   char *ver="???";
1005
1006   switch(opt.compliance)
1007     {
1008     case CO_GNUPG:   return "--gnupg";
1009     case CO_RFC4880: return "--openpgp";
1010     case CO_RFC2440: return "--rfc2440";
1011     case CO_RFC1991: return "--rfc1991";
1012     case CO_PGP2:    return "--pgp2";
1013     case CO_PGP6:    return "--pgp6";
1014     case CO_PGP7:    return "--pgp7";
1015     case CO_PGP8:    return "--pgp8";
1016     }
1017
1018   return ver;
1019 }
1020
1021 void
1022 compliance_failure(void)
1023 {
1024   char *ver="???";
1025
1026   switch(opt.compliance)
1027     {
1028     case CO_GNUPG:
1029       ver="GnuPG";
1030       break;
1031
1032     case CO_RFC4880:
1033       ver="OpenPGP";
1034       break;
1035
1036     case CO_RFC2440:
1037       ver="OpenPGP (older)";
1038       break;
1039
1040     case CO_RFC1991:
1041       ver="old PGP";
1042       break;
1043
1044     case CO_PGP2:
1045       ver="PGP 2.x";
1046       break;
1047
1048     case CO_PGP6:
1049       ver="PGP 6.x";
1050       break;
1051
1052     case CO_PGP7:
1053       ver="PGP 7.x";
1054       break;
1055
1056     case CO_PGP8:
1057       ver="PGP 8.x";
1058       break;
1059     }
1060
1061   log_info(_("this message may not be usable by %s\n"),ver);
1062   opt.compliance=CO_GNUPG;
1063 }
1064
1065 /* Break a string into successive option pieces.  Accepts single word
1066    options and key=value argument options. */
1067 char *
1068 optsep(char **stringp)
1069 {
1070   char *tok,*end;
1071
1072   tok=*stringp;
1073   if(tok)
1074     {
1075       end=strpbrk(tok," ,=");
1076       if(end)
1077         {
1078           int sawequals=0;
1079           char *ptr=end;
1080
1081           /* what we need to do now is scan along starting with *end,
1082              If the next character we see (ignoring spaces) is an =
1083              sign, then there is an argument. */
1084
1085           while(*ptr)
1086             {
1087               if(*ptr=='=')
1088                 sawequals=1;
1089               else if(*ptr!=' ')
1090                 break;
1091               ptr++;
1092             }
1093
1094           /* There is an argument, so grab that too.  At this point,
1095              ptr points to the first character of the argument. */
1096           if(sawequals)
1097             {
1098               /* Is it a quoted argument? */
1099               if(*ptr=='"')
1100                 {
1101                   ptr++;
1102                   end=strchr(ptr,'"');
1103                   if(end)
1104                     end++;
1105                 }
1106               else
1107                 end=strpbrk(ptr," ,");
1108             }
1109
1110           if(end && *end)
1111             {
1112               *end='\0';
1113               *stringp=end+1;
1114             }
1115           else
1116             *stringp=NULL;
1117         }
1118       else
1119         *stringp=NULL;
1120     }
1121
1122   return tok;
1123 }
1124
1125 /* Breaks an option value into key and value.  Returns NULL if there
1126    is no value.  Note that "string" is modified to remove the =value
1127    part. */
1128 char *
1129 argsplit(char *string)
1130 {
1131   char *equals,*arg=NULL;
1132
1133   equals=strchr(string,'=');
1134   if(equals)
1135     {
1136       char *quote,*space;
1137
1138       *equals='\0';
1139       arg=equals+1;
1140
1141       /* Quoted arg? */
1142       quote=strchr(arg,'"');
1143       if(quote)
1144         {
1145           arg=quote+1;
1146
1147           quote=strchr(arg,'"');
1148           if(quote)
1149             *quote='\0';
1150         }
1151       else
1152         {
1153           size_t spaces;
1154
1155           /* Trim leading spaces off of the arg */
1156           spaces=strspn(arg," ");
1157           arg+=spaces;
1158         }
1159
1160       /* Trim tailing spaces off of the tag */
1161       space=strchr(string,' ');
1162       if(space)
1163         *space='\0';
1164     }
1165
1166   return arg;
1167 }
1168
1169 /* Return the length of the initial token, leaving off any
1170    argument. */
1171 static size_t
1172 optlen(const char *s)
1173 {
1174   char *end=strpbrk(s," =");
1175
1176   if(end)
1177     return end-s;
1178   else
1179     return strlen(s);
1180 }
1181
1182 int
1183 parse_options(char *str,unsigned int *options,
1184               struct parse_options *opts,int noisy)
1185 {
1186   char *tok;
1187
1188   if (str && !strcmp (str, "help"))
1189     {
1190       int i,maxlen=0;
1191
1192       /* Figure out the longest option name so we can line these up
1193          neatly. */
1194       for(i=0;opts[i].name;i++)
1195         if(opts[i].help && maxlen<strlen(opts[i].name))
1196           maxlen=strlen(opts[i].name);
1197
1198       for(i=0;opts[i].name;i++)
1199         if(opts[i].help)
1200           printf("%s%*s%s\n",opts[i].name,
1201                  maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1202
1203       g10_exit(0);
1204     }
1205
1206   while((tok=optsep(&str)))
1207     {
1208       int i,rev=0;
1209       char *otok=tok;
1210
1211       if(tok[0]=='\0')
1212         continue;
1213
1214       if(ascii_strncasecmp("no-",tok,3)==0)
1215         {
1216           rev=1;
1217           tok+=3;
1218         }
1219
1220       for(i=0;opts[i].name;i++)
1221         {
1222           size_t toklen=optlen(tok);
1223
1224           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1225             {
1226               /* We have a match, but it might be incomplete */
1227               if(toklen!=strlen(opts[i].name))
1228                 {
1229                   int j;
1230
1231                   for(j=i+1;opts[j].name;j++)
1232                     {
1233                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1234                         {
1235                           if(noisy)
1236                             log_info(_("ambiguous option `%s'\n"),otok);
1237                           return 0;
1238                         }
1239                     }
1240                 }
1241
1242               if(rev)
1243                 {
1244                   *options&=~opts[i].bit;
1245                   if(opts[i].value)
1246                     *opts[i].value=NULL;
1247                 }
1248               else
1249                 {
1250                   *options|=opts[i].bit;
1251                   if(opts[i].value)
1252                     *opts[i].value=argsplit(tok);
1253                 }
1254               break;
1255             }
1256         }
1257
1258       if(!opts[i].name)
1259         {
1260           if(noisy)
1261             log_info(_("unknown option `%s'\n"),otok);
1262           return 0;
1263         }
1264     }
1265
1266   return 1;
1267 }
1268
1269
1270 /* Check whether the string has characters not valid in an RFC-822
1271    address.  To cope with OpenPGP we ignore non-ascii characters
1272    so that for example umlauts are legal in an email address.  An
1273    OpenPGP user ID must be utf-8 encoded but there is no strict
1274    requirement for RFC-822.  Thus to avoid IDNA encoding we put the
1275    address verbatim as utf-8 into the user ID under the assumption
1276    that mail programs handle IDNA at a lower level and take OpenPGP
1277    user IDs as utf-8.  Note that we can't do an utf-8 encoding
1278    checking here because in keygen.c this function is called with the
1279    native encoding and native to utf-8 encoding is only done  later.  */
1280 int
1281 has_invalid_email_chars (const char *s)
1282 {
1283   int at_seen=0;
1284   const char *valid_chars=
1285     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1286
1287   for ( ; *s; s++ )
1288     {
1289       if ( (*s & 0x80) )
1290         continue; /* We only care about ASCII.  */
1291       if ( *s == '@' )
1292         at_seen=1;
1293       else if ( !at_seen && !(strchr (valid_chars, *s)
1294                               || strchr ("!#$%&'*+/=?^`{|}~", *s)))
1295         return 1;
1296       else if ( at_seen && !strchr( valid_chars, *s ) )
1297         return 1;
1298     }
1299   return 0;
1300 }
1301
1302
1303 /* Check whether NAME represents a valid mailbox according to
1304    RFC822. Returns true if so. */
1305 int
1306 is_valid_mailbox (const char *name)
1307 {
1308   return !( !name
1309             || !*name
1310             || has_invalid_email_chars (name)
1311             || string_count_chr (name,'@') != 1
1312             || *name == '@'
1313             || name[strlen(name)-1] == '@'
1314             || name[strlen(name)-1] == '.'
1315             || strstr (name, "..") );
1316 }
1317
1318
1319 /* Similar to access(2), but uses PATH to find the file. */
1320 int
1321 path_access(const char *file,int mode)
1322 {
1323   char *envpath;
1324   int ret=-1;
1325
1326   envpath=getenv("PATH");
1327
1328   if(!envpath
1329 #ifdef HAVE_DRIVE_LETTERS
1330      || (((file[0]>='A' && file[0]<='Z')
1331           || (file[0]>='a' && file[0]<='z'))
1332          && file[1]==':')
1333 #else
1334      || file[0]=='/'
1335 #endif
1336      )
1337     return access(file,mode);
1338   else
1339     {
1340       /* At least as large as, but most often larger than we need. */
1341       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1342       char *split,*item,*path=xstrdup(envpath);
1343
1344       split=path;
1345
1346       while((item=strsep(&split,PATHSEP_S)))
1347         {
1348           strcpy(buffer,item);
1349           strcat(buffer,"/");
1350           strcat(buffer,file);
1351           ret=access(buffer,mode);
1352           if(ret==0)
1353             break;
1354         }
1355
1356       xfree(path);
1357       xfree(buffer);
1358     }
1359
1360   return ret;
1361 }
1362
1363
1364 \f
1365 /* Return the number of public key parameters as used by OpenPGP.  */
1366 int
1367 pubkey_get_npkey (int algo)
1368 {
1369   size_t n;
1370
1371   /* ECC is special.  */
1372   if (algo == PUBKEY_ALGO_ECDSA)
1373     return 2;
1374   else if (algo == PUBKEY_ALGO_ECDH)
1375     return 3;
1376
1377   /* All other algorithms match those of Libgcrypt.  */
1378   if (algo == GCRY_PK_ELG_E)
1379     algo = GCRY_PK_ELG;
1380
1381   if (gcry_pk_algo_info (algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &n))
1382     n = 0;
1383   return n;
1384 }
1385
1386
1387 /* Return the number of secret key parameters as used by OpenPGP.  */
1388 int
1389 pubkey_get_nskey (int algo)
1390 {
1391   size_t n;
1392
1393   /* ECC is special.  */
1394   if (algo == PUBKEY_ALGO_ECDSA)
1395     return 3;
1396   else if (algo == PUBKEY_ALGO_ECDH)
1397     return 4;
1398
1399   /* All other algorithms match those of Libgcrypt.  */
1400   if (algo == GCRY_PK_ELG_E)
1401     algo = GCRY_PK_ELG;
1402
1403   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &n ))
1404     n = 0;
1405   return n;
1406 }
1407
1408 /* Temporary helper. */
1409 int
1410 pubkey_get_nsig (int algo)
1411 {
1412   size_t n;
1413
1414   /* ECC is special.  */
1415   if (algo == PUBKEY_ALGO_ECDSA)
1416     return 2;
1417   else if (algo == PUBKEY_ALGO_ECDH)
1418     return 0;
1419
1420   if (algo == GCRY_PK_ELG_E)
1421     algo = GCRY_PK_ELG;
1422
1423   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSIGN, NULL, &n))
1424     n = 0;
1425   return n;
1426 }
1427
1428
1429 /* Temporary helper. */
1430 int
1431 pubkey_get_nenc (int algo)
1432 {
1433   size_t n;
1434
1435   /* ECC is special.  */
1436   if (algo == PUBKEY_ALGO_ECDSA)
1437     return 0;
1438   else if (algo == PUBKEY_ALGO_ECDH)
1439     return 2;
1440
1441   if (algo == GCRY_PK_ELG_E)
1442     algo = GCRY_PK_ELG;
1443
1444   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NENCR, NULL, &n ))
1445     n = 0;
1446   return n;
1447 }
1448
1449
1450 /* Temporary helper. */
1451 unsigned int
1452 pubkey_nbits( int algo, gcry_mpi_t *key )
1453 {
1454     int rc, nbits;
1455     gcry_sexp_t sexp;
1456
1457     if( algo == PUBKEY_ALGO_DSA ) {
1458         rc = gcry_sexp_build ( &sexp, NULL,
1459                               "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1460                                   key[0], key[1], key[2], key[3] );
1461     }
1462     else if( algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E ) {
1463         rc = gcry_sexp_build ( &sexp, NULL,
1464                               "(public-key(elg(p%m)(g%m)(y%m)))",
1465                                   key[0], key[1], key[2] );
1466     }
1467     else if( is_RSA (algo) ) {
1468         rc = gcry_sexp_build ( &sexp, NULL,
1469                               "(public-key(rsa(n%m)(e%m)))",
1470                                   key[0], key[1] );
1471     }
1472     else if( algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_ECDH ) {
1473         char *curve = openpgp_oid_to_str (key[0]);
1474         if (!curve)
1475           rc = gpg_error_from_syserror ();
1476         else
1477           {
1478             rc = gcry_sexp_build (&sexp, NULL,
1479                                   "(public-key(ecc(curve%s)(q%m)))",
1480                                   curve, key[1]);
1481             xfree (curve);
1482           }
1483     }
1484     else
1485         return 0;
1486
1487     if ( rc )
1488         BUG ();
1489
1490     nbits = gcry_pk_get_nbits( sexp );
1491     gcry_sexp_release( sexp );
1492     return nbits;
1493 }
1494
1495
1496
1497 int
1498 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1499 {
1500   int n=0;
1501
1502   if (!a)
1503     return es_fprintf (fp, "[MPI_NULL]");
1504   if (!mode)
1505     {
1506       unsigned int n1;
1507       n1 = gcry_mpi_get_nbits(a);
1508       n += es_fprintf (fp, "[%u bits]", n1);
1509     }
1510   else if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
1511     {
1512       unsigned int nbits;
1513       unsigned char *p = gcry_mpi_get_opaque (a, &nbits);
1514       if (!p)
1515         n += es_fprintf (fp, "[invalid opaque value]");
1516       else
1517         {
1518           nbits = (nbits + 7)/8;
1519           for (; nbits; nbits--, p++)
1520             n += es_fprintf (fp, "%02X", *p);
1521         }
1522     }
1523   else
1524     {
1525       unsigned char *buffer;
1526
1527       if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a))
1528         BUG ();
1529       es_fputs (buffer, fp);
1530       n += strlen (buffer);
1531       gcry_free (buffer);
1532     }
1533   return n;
1534 }
1535
1536
1537 /* pkey[1] or skey[1] is Q for ECDSA, which is an uncompressed point,
1538    i.e.  04 <x> <y> */
1539 unsigned int
1540 ecdsa_qbits_from_Q (unsigned int qbits)
1541 {
1542   if ((qbits%8) > 3)
1543     {
1544       log_error (_("ECDSA public key is expected to be in SEC encoding "
1545                    "multiple of 8 bits\n"));
1546       return 0;
1547     }
1548   qbits -= qbits%8;
1549   qbits /= 2;
1550   return qbits;
1551 }