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