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