gpg: Support EAX if for latest Libgcrypt.
[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_LOGLVL_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 supported.  Return an error if not. */
586 gpg_error_t
587 openpgp_aead_test_algo (aead_algo_t algo)
588 {
589   switch (algo)
590     {
591     case AEAD_ALGO_NONE:
592       break;
593     case AEAD_ALGO_EAX:
594     case AEAD_ALGO_OCB:
595       return 0;
596     }
597
598   return gpg_error (GPG_ERR_INV_CIPHER_MODE);
599 }
600
601
602 /* Map the OpenPGP AEAD algorithm with ID ALGO to a string
603  * representation of the algorithm name.  For unknown algorithm IDs
604  * this function returns "?".  */
605 const char *
606 openpgp_aead_algo_name (aead_algo_t algo)
607 {
608   switch (algo)
609     {
610     case AEAD_ALGO_NONE:  break;
611     case AEAD_ALGO_EAX:   return "EAX";
612     case AEAD_ALGO_OCB:   return "OCB";
613     }
614
615   return "?";
616 }
617
618
619 /* Return 0 if ALGO is a supported OpenPGP public key algorithm.  */
620 int
621 openpgp_pk_test_algo (pubkey_algo_t algo)
622 {
623   return openpgp_pk_test_algo2 (algo, 0);
624 }
625
626
627 /* Return 0 if ALGO is a supported OpenPGP public key algorithm and
628    allows the usage USE.  */
629 int
630 openpgp_pk_test_algo2 (pubkey_algo_t algo, unsigned int use)
631 {
632   enum gcry_pk_algos ga = 0;
633   size_t use_buf = use;
634
635   switch (algo)
636     {
637 #ifdef GPG_USE_RSA
638     case PUBKEY_ALGO_RSA:       ga = GCRY_PK_RSA;   break;
639     case PUBKEY_ALGO_RSA_E:     ga = GCRY_PK_RSA_E; break;
640     case PUBKEY_ALGO_RSA_S:     ga = GCRY_PK_RSA_S; break;
641 #else
642     case PUBKEY_ALGO_RSA:       break;
643     case PUBKEY_ALGO_RSA_E:     break;
644     case PUBKEY_ALGO_RSA_S:     break;
645 #endif
646
647     case PUBKEY_ALGO_ELGAMAL_E: ga = GCRY_PK_ELG;   break;
648     case PUBKEY_ALGO_DSA:       ga = GCRY_PK_DSA;   break;
649
650 #ifdef GPG_USE_ECDH
651     case PUBKEY_ALGO_ECDH:      ga = GCRY_PK_ECC;   break;
652 #else
653     case PUBKEY_ALGO_ECDH:      break;
654 #endif
655
656 #ifdef GPG_USE_ECDSA
657     case PUBKEY_ALGO_ECDSA:     ga = GCRY_PK_ECC;   break;
658 #else
659     case PUBKEY_ALGO_ECDSA:     break;
660 #endif
661
662 #ifdef GPG_USE_EDDSA
663     case PUBKEY_ALGO_EDDSA:     ga = GCRY_PK_ECC;   break;
664 #else
665     case PUBKEY_ALGO_EDDSA:     break;
666 #endif
667
668     case PUBKEY_ALGO_ELGAMAL:
669       /* Dont't allow type 20 keys unless in rfc2440 mode.  */
670       if (RFC2440)
671         ga = GCRY_PK_ELG;
672       break;
673
674     default:
675       break;
676     }
677   if (!ga)
678     return gpg_error (GPG_ERR_PUBKEY_ALGO);
679
680   /* Now check whether Libgcrypt has support for the algorithm.  */
681   return gcry_pk_algo_info (ga, GCRYCTL_TEST_ALGO, NULL, &use_buf);
682 }
683
684
685 int
686 openpgp_pk_algo_usage ( int algo )
687 {
688     int use = 0;
689
690     /* They are hardwired in gpg 1.0. */
691     switch ( algo ) {
692       case PUBKEY_ALGO_RSA:
693           use = (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG
694                  | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH);
695           break;
696       case PUBKEY_ALGO_RSA_E:
697       case PUBKEY_ALGO_ECDH:
698           use = PUBKEY_USAGE_ENC;
699           break;
700       case PUBKEY_ALGO_RSA_S:
701           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG;
702           break;
703       case PUBKEY_ALGO_ELGAMAL:
704           if (RFC2440)
705              use = PUBKEY_USAGE_ENC;
706           break;
707       case PUBKEY_ALGO_ELGAMAL_E:
708           use = PUBKEY_USAGE_ENC;
709           break;
710       case PUBKEY_ALGO_DSA:
711           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
712           break;
713       case PUBKEY_ALGO_ECDSA:
714       case PUBKEY_ALGO_EDDSA:
715           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
716       default:
717           break;
718     }
719     return use;
720 }
721
722 /* Map the OpenPGP pubkey algorithm whose ID is contained in ALGO to a
723    string representation of the algorithm name.  For unknown algorithm
724    IDs this function returns "?".  */
725 const char *
726 openpgp_pk_algo_name (pubkey_algo_t algo)
727 {
728   switch (algo)
729     {
730     case PUBKEY_ALGO_RSA:
731     case PUBKEY_ALGO_RSA_E:
732     case PUBKEY_ALGO_RSA_S:     return "RSA";
733     case PUBKEY_ALGO_ELGAMAL:
734     case PUBKEY_ALGO_ELGAMAL_E: return "ELG";
735     case PUBKEY_ALGO_DSA:       return "DSA";
736     case PUBKEY_ALGO_ECDH:      return "ECDH";
737     case PUBKEY_ALGO_ECDSA:     return "ECDSA";
738     case PUBKEY_ALGO_EDDSA:     return "EDDSA";
739     default: return "?";
740     }
741 }
742
743
744 /* Explicit mapping of OpenPGP digest algos to Libgcrypt.  */
745 /* FIXME: We do not yes use it everywhere.  */
746 enum gcry_md_algos
747 map_md_openpgp_to_gcry (digest_algo_t algo)
748 {
749   switch (algo)
750     {
751 #ifdef GPG_USE_MD5
752     case DIGEST_ALGO_MD5:    return GCRY_MD_MD5;
753 #else
754     case DIGEST_ALGO_MD5:    return 0;
755 #endif
756
757     case DIGEST_ALGO_SHA1:   return GCRY_MD_SHA1;
758
759 #ifdef GPG_USE_RMD160
760     case DIGEST_ALGO_RMD160: return GCRY_MD_RMD160;
761 #else
762     case DIGEST_ALGO_RMD160: return 0;
763 #endif
764
765 #ifdef GPG_USE_SHA224
766     case DIGEST_ALGO_SHA224: return GCRY_MD_SHA224;
767 #else
768     case DIGEST_ALGO_SHA224: return 0;
769 #endif
770
771     case DIGEST_ALGO_SHA256: return GCRY_MD_SHA256;
772
773 #ifdef GPG_USE_SHA384
774     case DIGEST_ALGO_SHA384: return GCRY_MD_SHA384;
775 #else
776     case DIGEST_ALGO_SHA384: return 0;
777 #endif
778
779 #ifdef GPG_USE_SHA512
780     case DIGEST_ALGO_SHA512: return GCRY_MD_SHA512;
781 #else
782     case DIGEST_ALGO_SHA512: return 0;
783 #endif
784     default: return 0;
785     }
786 }
787
788
789 /* Return 0 if ALGO is suitable and implemented OpenPGP hash
790    algorithm.  */
791 int
792 openpgp_md_test_algo (digest_algo_t algo)
793 {
794   enum gcry_md_algos ga;
795
796   ga = map_md_openpgp_to_gcry (algo);
797   if (!ga)
798     return gpg_error (GPG_ERR_DIGEST_ALGO);
799
800   return gcry_md_test_algo (ga);
801 }
802
803
804 /* Map the OpenPGP digest algorithm whose ID is contained in ALGO to a
805    string representation of the algorithm name.  For unknown algorithm
806    IDs this function returns "?".  */
807 const char *
808 openpgp_md_algo_name (int algo)
809 {
810   switch (algo)
811     {
812     case DIGEST_ALGO_MD5:    return "MD5";
813     case DIGEST_ALGO_SHA1:   return "SHA1";
814     case DIGEST_ALGO_RMD160: return "RIPEMD160";
815     case DIGEST_ALGO_SHA256: return "SHA256";
816     case DIGEST_ALGO_SHA384: return "SHA384";
817     case DIGEST_ALGO_SHA512: return "SHA512";
818     case DIGEST_ALGO_SHA224: return "SHA224";
819     }
820   return "?";
821 }
822
823
824 static unsigned long
825 get_signature_count (PKT_public_key *pk)
826 {
827 #ifdef ENABLE_CARD_SUPPORT
828   struct agent_card_info_s info;
829
830   (void)pk;
831   if (!agent_scd_getattr ("SIG-COUNTER",&info))
832     return info.sig_counter;
833   else
834     return 0;
835 #else
836   (void)pk;
837   return 0;
838 #endif
839 }
840
841 /* Expand %-strings.  Returns a string which must be xfreed.  Returns
842    NULL if the string cannot be expanded (too large). */
843 char *
844 pct_expando(const char *string,struct expando_args *args)
845 {
846   const char *ch=string;
847   int idx=0,maxlen=0,done=0;
848   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
849   char *ret=NULL;
850
851   if(args->pk)
852     keyid_from_pk(args->pk,pk_keyid);
853
854   if(args->pksk)
855     keyid_from_pk (args->pksk, sk_keyid);
856
857   /* This is used so that %k works in photoid command strings in
858      --list-secret-keys (which of course has a sk, but no pk). */
859   if(!args->pk && args->pksk)
860     keyid_from_pk (args->pksk, pk_keyid);
861
862   while(*ch!='\0')
863     {
864       if(!done)
865         {
866           /* 8192 is way bigger than we'll need here */
867           if(maxlen>=8192)
868             goto fail;
869
870           maxlen+=1024;
871           ret=xrealloc(ret,maxlen);
872         }
873
874       done=0;
875
876       if(*ch=='%')
877         {
878           switch(*(ch+1))
879             {
880             case 's': /* short key id */
881               if(idx+8<maxlen)
882                 {
883                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
884                   idx+=8;
885                   done=1;
886                 }
887               break;
888
889             case 'S': /* long key id */
890               if(idx+16<maxlen)
891                 {
892                   sprintf(&ret[idx],"%08lX%08lX",
893                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
894                   idx+=16;
895                   done=1;
896                 }
897               break;
898
899             case 'k': /* short key id */
900               if(idx+8<maxlen)
901                 {
902                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
903                   idx+=8;
904                   done=1;
905                 }
906               break;
907
908             case 'K': /* long key id */
909               if(idx+16<maxlen)
910                 {
911                   sprintf(&ret[idx],"%08lX%08lX",
912                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
913                   idx+=16;
914                   done=1;
915                 }
916               break;
917
918             case 'U': /* z-base-32 encoded user id hash. */
919               if (args->namehash)
920                 {
921                   char *tmp = zb32_encode (args->namehash, 8*20);
922                   if (tmp)
923                     {
924                       if (idx + strlen (tmp) < maxlen)
925                         {
926                           strcpy (ret+idx, tmp);
927                           idx += strlen (tmp);
928                         }
929                       xfree (tmp);
930                       done = 1;
931                     }
932                 }
933               break;
934
935             case 'c': /* signature count from card, if any. */
936               if(idx+10<maxlen)
937                 {
938                   sprintf (&ret[idx],"%lu", get_signature_count (args->pksk));
939                   idx+=strlen(&ret[idx]);
940                   done=1;
941                 }
942               break;
943
944             case 'f': /* Fingerprint of key being signed */
945             case 'p': /* Fingerprint of the primary key making the signature. */
946             case 'g': /* Fingerprint of the key making the signature.  */
947               {
948                 byte array[MAX_FINGERPRINT_LEN];
949                 size_t len;
950                 int i;
951
952                 if ((*(ch+1))=='f' && args->pk)
953                   fingerprint_from_pk (args->pk, array, &len);
954                 else if ((*(ch+1))=='p' && args->pksk)
955                   {
956                     if(args->pksk->flags.primary)
957                       fingerprint_from_pk (args->pksk, array, &len);
958                     else if (args->pksk->main_keyid[0]
959                              || args->pksk->main_keyid[1])
960                       {
961                         /* Not the primary key: Find the fingerprint
962                            of the primary key.  */
963                         PKT_public_key *pk=
964                           xmalloc_clear(sizeof(PKT_public_key));
965
966                         if (!get_pubkey_fast (pk,args->pksk->main_keyid))
967                           fingerprint_from_pk (pk, array, &len);
968                         else
969                           memset (array, 0, (len=MAX_FINGERPRINT_LEN));
970                         free_public_key (pk);
971                       }
972                     else /* Oops: info about the primary key missing.  */
973                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
974                   }
975                 else if((*(ch+1))=='g' && args->pksk)
976                   fingerprint_from_pk (args->pksk, array, &len);
977                 else
978                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
979
980                 if(idx+(len*2)<maxlen)
981                   {
982                     for(i=0;i<len;i++)
983                       {
984                         sprintf(&ret[idx],"%02X",array[i]);
985                         idx+=2;
986                       }
987                     done=1;
988                   }
989               }
990               break;
991
992             case 'v': /* validity letters */
993               if(args->validity_info && idx+1<maxlen)
994                 {
995                   ret[idx++]=args->validity_info;
996                   ret[idx]='\0';
997                   done=1;
998                 }
999               break;
1000
1001               /* The text string types */
1002             case 't':
1003             case 'T':
1004             case 'V':
1005               {
1006                 const char *str=NULL;
1007
1008                 switch(*(ch+1))
1009                   {
1010                   case 't': /* e.g. "jpg" */
1011                     str=image_type_to_string(args->imagetype,0);
1012                     break;
1013
1014                   case 'T': /* e.g. "image/jpeg" */
1015                     str=image_type_to_string(args->imagetype,2);
1016                     break;
1017
1018                   case 'V': /* e.g. "full", "expired", etc. */
1019                     str=args->validity_string;
1020                     break;
1021                   }
1022
1023                 if(str && idx+strlen(str)<maxlen)
1024                   {
1025                     strcpy(&ret[idx],str);
1026                     idx+=strlen(str);
1027                     done=1;
1028                   }
1029               }
1030               break;
1031
1032             case '%':
1033               if(idx+1<maxlen)
1034                 {
1035                   ret[idx++]='%';
1036                   ret[idx]='\0';
1037                   done=1;
1038                 }
1039               break;
1040
1041               /* Any unknown %-keys (like %i, %o, %I, and %O) are
1042                  passed through for later expansion.  Note this also
1043                  handles the case where the last character in the
1044                  string is a '%' - the terminating \0 will end up here
1045                  and properly terminate the string. */
1046             default:
1047               if(idx+2<maxlen)
1048                 {
1049                   ret[idx++]='%';
1050                   ret[idx++]=*(ch+1);
1051                   ret[idx]='\0';
1052                   done=1;
1053                 }
1054               break;
1055               }
1056
1057           if(done)
1058             ch++;
1059         }
1060       else
1061         {
1062           if(idx+1<maxlen)
1063             {
1064               ret[idx++]=*ch;
1065               ret[idx]='\0';
1066               done=1;
1067             }
1068         }
1069
1070       if(done)
1071         ch++;
1072     }
1073
1074   return ret;
1075
1076  fail:
1077   xfree(ret);
1078   return NULL;
1079 }
1080
1081 void
1082 deprecated_warning(const char *configname,unsigned int configlineno,
1083                    const char *option,const char *repl1,const char *repl2)
1084 {
1085   if(configname)
1086     {
1087       if(strncmp("--",option,2)==0)
1088         option+=2;
1089
1090       if(strncmp("--",repl1,2)==0)
1091         repl1+=2;
1092
1093       log_info(_("%s:%d: deprecated option \"%s\"\n"),
1094                configname,configlineno,option);
1095     }
1096   else
1097     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
1098
1099   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
1100 }
1101
1102
1103 void
1104 deprecated_command (const char *name)
1105 {
1106   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
1107            name);
1108 }
1109
1110
1111 void
1112 obsolete_scdaemon_option (const char *configname, unsigned int configlineno,
1113                           const char *name)
1114 {
1115   if (configname)
1116     log_info (_("%s:%u: \"%s\" is obsolete in this file"
1117                 " - it only has effect in %s\n"),
1118               configname, configlineno, name, SCDAEMON_NAME EXTSEP_S "conf");
1119   else
1120     log_info (_("WARNING: \"%s%s\" is an obsolete option"
1121                 " - it has no effect except on %s\n"),
1122               "--", name, SCDAEMON_NAME);
1123 }
1124
1125
1126 /*
1127  * Wrapper around gcry_cipher_map_name to provide a fallback using the
1128  * "Sn" syntax as used by the preference strings.
1129  */
1130 int
1131 string_to_cipher_algo (const char *string)
1132 {
1133   int val;
1134
1135   val = map_cipher_gcry_to_openpgp (gcry_cipher_map_name (string));
1136   if (!val && string && (string[0]=='S' || string[0]=='s'))
1137     {
1138       char *endptr;
1139
1140       string++;
1141       val = strtol (string, &endptr, 10);
1142       if (!*string || *endptr || openpgp_cipher_test_algo (val))
1143         val = 0;
1144     }
1145
1146   return val;
1147 }
1148
1149
1150 /*
1151  * Map an AEAD mode string to a an AEAD algorithm number as defined by
1152  * rrc4880bis.  Also support the "An" syntax as used by the preference
1153  * strings.
1154  */
1155 aead_algo_t
1156 string_to_aead_algo (const char *string)
1157 {
1158   int result;
1159
1160   if (!string)
1161     result = 0;
1162   if (!ascii_strcasecmp (string, "EAX"))
1163     result = 1;
1164   else if (!ascii_strcasecmp (string, "OCB"))
1165     result = 2;
1166   else if ((string[0]=='A' || string[0]=='a'))
1167     {
1168       char *endptr;
1169
1170       string++;
1171       result = strtol (string, &endptr, 10);
1172       if (!*string || *endptr || result < 1 || result > 2)
1173         result = 0;
1174     }
1175   else
1176     result = 0;
1177
1178   return result;
1179 }
1180
1181
1182 /*
1183  * Wrapper around gcry_md_map_name to provide a fallback using the
1184  * "Hn" syntax as used by the preference strings.
1185  */
1186 int
1187 string_to_digest_algo (const char *string)
1188 {
1189   int val;
1190
1191   /* FIXME: We should make use of our wrapper function and not assume
1192      that there is a 1 to 1 mapping between OpenPGP and Libgcrypt.  */
1193   val = gcry_md_map_name (string);
1194   if (!val && string && (string[0]=='H' || string[0]=='h'))
1195     {
1196       char *endptr;
1197
1198       string++;
1199       val = strtol (string, &endptr, 10);
1200       if (!*string || *endptr || openpgp_md_test_algo (val))
1201         val = 0;
1202     }
1203
1204   return val;
1205 }
1206
1207
1208
1209 const char *
1210 compress_algo_to_string(int algo)
1211 {
1212   const char *s=NULL;
1213
1214   switch(algo)
1215     {
1216     case COMPRESS_ALGO_NONE:
1217       s=_("Uncompressed");
1218       break;
1219
1220     case COMPRESS_ALGO_ZIP:
1221       s="ZIP";
1222       break;
1223
1224     case COMPRESS_ALGO_ZLIB:
1225       s="ZLIB";
1226       break;
1227
1228 #ifdef HAVE_BZIP2
1229     case COMPRESS_ALGO_BZIP2:
1230       s="BZIP2";
1231       break;
1232 #endif
1233     }
1234
1235   return s;
1236 }
1237
1238 int
1239 string_to_compress_algo(const char *string)
1240 {
1241   /* TRANSLATORS: See doc/TRANSLATE about this string. */
1242   if(match_multistr(_("uncompressed|none"),string))
1243     return 0;
1244   else if(ascii_strcasecmp(string,"uncompressed")==0)
1245     return 0;
1246   else if(ascii_strcasecmp(string,"none")==0)
1247     return 0;
1248   else if(ascii_strcasecmp(string,"zip")==0)
1249     return 1;
1250   else if(ascii_strcasecmp(string,"zlib")==0)
1251     return 2;
1252 #ifdef HAVE_BZIP2
1253   else if(ascii_strcasecmp(string,"bzip2")==0)
1254     return 3;
1255 #endif
1256   else if(ascii_strcasecmp(string,"z0")==0)
1257     return 0;
1258   else if(ascii_strcasecmp(string,"z1")==0)
1259     return 1;
1260   else if(ascii_strcasecmp(string,"z2")==0)
1261     return 2;
1262 #ifdef HAVE_BZIP2
1263   else if(ascii_strcasecmp(string,"z3")==0)
1264     return 3;
1265 #endif
1266   else
1267     return -1;
1268 }
1269
1270 int
1271 check_compress_algo(int algo)
1272 {
1273   switch (algo)
1274     {
1275     case 0: return 0;
1276 #ifdef HAVE_ZIP
1277     case 1:
1278     case 2: return 0;
1279 #endif
1280 #ifdef HAVE_BZIP2
1281     case 3: return 0;
1282 #endif
1283     default: return GPG_ERR_COMPR_ALGO;
1284     }
1285 }
1286
1287 int
1288 default_cipher_algo(void)
1289 {
1290   if(opt.def_cipher_algo)
1291     return opt.def_cipher_algo;
1292   else if(opt.personal_cipher_prefs)
1293     return opt.personal_cipher_prefs[0].value;
1294   else
1295     return opt.s2k_cipher_algo;
1296 }
1297
1298
1299 aead_algo_t
1300 default_aead_algo(void)
1301 {
1302   if(opt.def_aead_algo)
1303     return opt.def_aead_algo;
1304   else if(opt.personal_aead_prefs)
1305     return opt.personal_aead_prefs[0].value;
1306   else
1307     return DEFAULT_AEAD_ALGO;
1308 }
1309
1310 /* There is no default_digest_algo function, but see
1311    sign.c:hash_for() */
1312
1313 int
1314 default_compress_algo(void)
1315 {
1316   if(opt.compress_algo!=-1)
1317     return opt.compress_algo;
1318   else if(opt.personal_compress_prefs)
1319     return opt.personal_compress_prefs[0].value;
1320   else
1321     return DEFAULT_COMPRESS_ALGO;
1322 }
1323
1324
1325 void
1326 compliance_failure(void)
1327 {
1328   char *ver="???";
1329
1330   switch(opt.compliance)
1331     {
1332     case CO_GNUPG:
1333       ver="GnuPG";
1334       break;
1335
1336     case CO_RFC4880:
1337       ver="OpenPGP";
1338       break;
1339
1340     case CO_RFC2440:
1341       ver="OpenPGP (older)";
1342       break;
1343
1344     case CO_PGP6:
1345       ver="PGP 6.x";
1346       break;
1347
1348     case CO_PGP7:
1349       ver="PGP 7.x";
1350       break;
1351
1352     case CO_PGP8:
1353       ver="PGP 8.x";
1354       break;
1355
1356     case CO_DE_VS:
1357       ver="DE-VS applications";
1358       break;
1359     }
1360
1361   log_info(_("this message may not be usable by %s\n"),ver);
1362   opt.compliance=CO_GNUPG;
1363 }
1364
1365 /* Break a string into successive option pieces.  Accepts single word
1366    options and key=value argument options. */
1367 char *
1368 optsep(char **stringp)
1369 {
1370   char *tok,*end;
1371
1372   tok=*stringp;
1373   if(tok)
1374     {
1375       end=strpbrk(tok," ,=");
1376       if(end)
1377         {
1378           int sawequals=0;
1379           char *ptr=end;
1380
1381           /* what we need to do now is scan along starting with *end,
1382              If the next character we see (ignoring spaces) is an =
1383              sign, then there is an argument. */
1384
1385           while(*ptr)
1386             {
1387               if(*ptr=='=')
1388                 sawequals=1;
1389               else if(*ptr!=' ')
1390                 break;
1391               ptr++;
1392             }
1393
1394           /* There is an argument, so grab that too.  At this point,
1395              ptr points to the first character of the argument. */
1396           if(sawequals)
1397             {
1398               /* Is it a quoted argument? */
1399               if(*ptr=='"')
1400                 {
1401                   ptr++;
1402                   end=strchr(ptr,'"');
1403                   if(end)
1404                     end++;
1405                 }
1406               else
1407                 end=strpbrk(ptr," ,");
1408             }
1409
1410           if(end && *end)
1411             {
1412               *end='\0';
1413               *stringp=end+1;
1414             }
1415           else
1416             *stringp=NULL;
1417         }
1418       else
1419         *stringp=NULL;
1420     }
1421
1422   return tok;
1423 }
1424
1425 /* Breaks an option value into key and value.  Returns NULL if there
1426    is no value.  Note that "string" is modified to remove the =value
1427    part. */
1428 char *
1429 argsplit(char *string)
1430 {
1431   char *equals,*arg=NULL;
1432
1433   equals=strchr(string,'=');
1434   if(equals)
1435     {
1436       char *quote,*space;
1437
1438       *equals='\0';
1439       arg=equals+1;
1440
1441       /* Quoted arg? */
1442       quote=strchr(arg,'"');
1443       if(quote)
1444         {
1445           arg=quote+1;
1446
1447           quote=strchr(arg,'"');
1448           if(quote)
1449             *quote='\0';
1450         }
1451       else
1452         {
1453           size_t spaces;
1454
1455           /* Trim leading spaces off of the arg */
1456           spaces=strspn(arg," ");
1457           arg+=spaces;
1458         }
1459
1460       /* Trim tailing spaces off of the tag */
1461       space=strchr(string,' ');
1462       if(space)
1463         *space='\0';
1464     }
1465
1466   return arg;
1467 }
1468
1469 /* Return the length of the initial token, leaving off any
1470    argument. */
1471 static size_t
1472 optlen(const char *s)
1473 {
1474   char *end=strpbrk(s," =");
1475
1476   if(end)
1477     return end-s;
1478   else
1479     return strlen(s);
1480 }
1481
1482 int
1483 parse_options(char *str,unsigned int *options,
1484               struct parse_options *opts,int noisy)
1485 {
1486   char *tok;
1487
1488   if (str && !strcmp (str, "help"))
1489     {
1490       int i,maxlen=0;
1491
1492       /* Figure out the longest option name so we can line these up
1493          neatly. */
1494       for(i=0;opts[i].name;i++)
1495         if(opts[i].help && maxlen<strlen(opts[i].name))
1496           maxlen=strlen(opts[i].name);
1497
1498       for(i=0;opts[i].name;i++)
1499         if(opts[i].help)
1500           es_printf("%s%*s%s\n",opts[i].name,
1501                     maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1502
1503       g10_exit(0);
1504     }
1505
1506   while((tok=optsep(&str)))
1507     {
1508       int i,rev=0;
1509       char *otok=tok;
1510
1511       if(tok[0]=='\0')
1512         continue;
1513
1514       if(ascii_strncasecmp("no-",tok,3)==0)
1515         {
1516           rev=1;
1517           tok+=3;
1518         }
1519
1520       for(i=0;opts[i].name;i++)
1521         {
1522           size_t toklen=optlen(tok);
1523
1524           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1525             {
1526               /* We have a match, but it might be incomplete */
1527               if(toklen!=strlen(opts[i].name))
1528                 {
1529                   int j;
1530
1531                   for(j=i+1;opts[j].name;j++)
1532                     {
1533                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1534                         {
1535                           if(noisy)
1536                             log_info(_("ambiguous option '%s'\n"),otok);
1537                           return 0;
1538                         }
1539                     }
1540                 }
1541
1542               if(rev)
1543                 {
1544                   *options&=~opts[i].bit;
1545                   if(opts[i].value)
1546                     *opts[i].value=NULL;
1547                 }
1548               else
1549                 {
1550                   *options|=opts[i].bit;
1551                   if(opts[i].value)
1552                     *opts[i].value=argsplit(tok);
1553                 }
1554               break;
1555             }
1556         }
1557
1558       if(!opts[i].name)
1559         {
1560           if(noisy)
1561             log_info(_("unknown option '%s'\n"),otok);
1562           return 0;
1563         }
1564     }
1565
1566   return 1;
1567 }
1568
1569
1570 /* Similar to access(2), but uses PATH to find the file. */
1571 int
1572 path_access(const char *file,int mode)
1573 {
1574   char *envpath;
1575   int ret=-1;
1576
1577   envpath=getenv("PATH");
1578
1579   if(!envpath
1580 #ifdef HAVE_DRIVE_LETTERS
1581      || (((file[0]>='A' && file[0]<='Z')
1582           || (file[0]>='a' && file[0]<='z'))
1583          && file[1]==':')
1584 #else
1585      || file[0]=='/'
1586 #endif
1587      )
1588     return access(file,mode);
1589   else
1590     {
1591       /* At least as large as, but most often larger than we need. */
1592       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1593       char *split,*item,*path=xstrdup(envpath);
1594
1595       split=path;
1596
1597       while((item=strsep(&split,PATHSEP_S)))
1598         {
1599           strcpy(buffer,item);
1600           strcat(buffer,"/");
1601           strcat(buffer,file);
1602           ret=access(buffer,mode);
1603           if(ret==0)
1604             break;
1605         }
1606
1607       xfree(path);
1608       xfree(buffer);
1609     }
1610
1611   return ret;
1612 }
1613
1614
1615 \f
1616 /* Return the number of public key parameters as used by OpenPGP.  */
1617 int
1618 pubkey_get_npkey (pubkey_algo_t algo)
1619 {
1620   switch (algo)
1621     {
1622     case PUBKEY_ALGO_RSA:
1623     case PUBKEY_ALGO_RSA_E:
1624     case PUBKEY_ALGO_RSA_S:     return 2;
1625     case PUBKEY_ALGO_ELGAMAL_E: return 3;
1626     case PUBKEY_ALGO_DSA:       return 4;
1627     case PUBKEY_ALGO_ECDH:      return 3;
1628     case PUBKEY_ALGO_ECDSA:     return 2;
1629     case PUBKEY_ALGO_ELGAMAL:   return 3;
1630     case PUBKEY_ALGO_EDDSA:     return 2;
1631     default: return 0;
1632     }
1633 }
1634
1635
1636 /* Return the number of secret key parameters as used by OpenPGP.  */
1637 int
1638 pubkey_get_nskey (pubkey_algo_t algo)
1639 {
1640   switch (algo)
1641     {
1642     case PUBKEY_ALGO_RSA:
1643     case PUBKEY_ALGO_RSA_E:
1644     case PUBKEY_ALGO_RSA_S:     return 6;
1645     case PUBKEY_ALGO_ELGAMAL_E: return 4;
1646     case PUBKEY_ALGO_DSA:       return 5;
1647     case PUBKEY_ALGO_ECDH:      return 4;
1648     case PUBKEY_ALGO_ECDSA:     return 3;
1649     case PUBKEY_ALGO_ELGAMAL:   return 4;
1650     case PUBKEY_ALGO_EDDSA:     return 3;
1651     default: return 0;
1652     }
1653 }
1654
1655 /* Temporary helper. */
1656 int
1657 pubkey_get_nsig (pubkey_algo_t algo)
1658 {
1659   switch (algo)
1660     {
1661     case PUBKEY_ALGO_RSA:
1662     case PUBKEY_ALGO_RSA_E:
1663     case PUBKEY_ALGO_RSA_S:     return 1;
1664     case PUBKEY_ALGO_ELGAMAL_E: return 0;
1665     case PUBKEY_ALGO_DSA:       return 2;
1666     case PUBKEY_ALGO_ECDH:      return 0;
1667     case PUBKEY_ALGO_ECDSA:     return 2;
1668     case PUBKEY_ALGO_ELGAMAL:   return 2;
1669     case PUBKEY_ALGO_EDDSA:     return 2;
1670     default: return 0;
1671     }
1672 }
1673
1674
1675 /* Temporary helper. */
1676 int
1677 pubkey_get_nenc (pubkey_algo_t algo)
1678 {
1679   switch (algo)
1680     {
1681     case PUBKEY_ALGO_RSA:
1682     case PUBKEY_ALGO_RSA_E:
1683     case PUBKEY_ALGO_RSA_S:     return 1;
1684     case PUBKEY_ALGO_ELGAMAL_E: return 2;
1685     case PUBKEY_ALGO_DSA:       return 0;
1686     case PUBKEY_ALGO_ECDH:      return 2;
1687     case PUBKEY_ALGO_ECDSA:     return 0;
1688     case PUBKEY_ALGO_ELGAMAL:   return 2;
1689     case PUBKEY_ALGO_EDDSA:     return 0;
1690     default: return 0;
1691     }
1692 }
1693
1694
1695 /* Temporary helper. */
1696 unsigned int
1697 pubkey_nbits( int algo, gcry_mpi_t *key )
1698 {
1699   int rc, nbits;
1700   gcry_sexp_t sexp;
1701
1702   if (algo == PUBKEY_ALGO_DSA
1703       && key[0] && key[1] && key[2] && key[3])
1704     {
1705       rc = gcry_sexp_build (&sexp, NULL,
1706                             "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1707                             key[0], key[1], key[2], key[3] );
1708     }
1709   else if ((algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E)
1710            && key[0] && key[1] && key[2])
1711     {
1712       rc = gcry_sexp_build (&sexp, NULL,
1713                             "(public-key(elg(p%m)(g%m)(y%m)))",
1714                             key[0], key[1], key[2] );
1715     }
1716   else if (is_RSA (algo)
1717            && key[0] && key[1])
1718     {
1719       rc = gcry_sexp_build (&sexp, NULL,
1720                             "(public-key(rsa(n%m)(e%m)))",
1721                             key[0], key[1] );
1722     }
1723   else if ((algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_ECDH
1724             || algo == PUBKEY_ALGO_EDDSA)
1725            && key[0] && key[1])
1726     {
1727       char *curve = openpgp_oid_to_str (key[0]);
1728       if (!curve)
1729         rc = gpg_error_from_syserror ();
1730       else
1731         {
1732           rc = gcry_sexp_build (&sexp, NULL,
1733                                 "(public-key(ecc(curve%s)(q%m)))",
1734                                 curve, key[1]);
1735           xfree (curve);
1736         }
1737     }
1738   else
1739     return 0;
1740
1741   if (rc)
1742     BUG ();
1743
1744   nbits = gcry_pk_get_nbits (sexp);
1745   gcry_sexp_release (sexp);
1746   return nbits;
1747 }
1748
1749
1750
1751 int
1752 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1753 {
1754   int n = 0;
1755   size_t nwritten;
1756
1757   if (!a)
1758     return es_fprintf (fp, "[MPI_NULL]");
1759   if (!mode)
1760     {
1761       unsigned int n1;
1762       n1 = gcry_mpi_get_nbits(a);
1763       n += es_fprintf (fp, "[%u bits]", n1);
1764     }
1765   else if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
1766     {
1767       unsigned int nbits;
1768       unsigned char *p = gcry_mpi_get_opaque (a, &nbits);
1769       if (!p)
1770         n += es_fprintf (fp, "[invalid opaque value]");
1771       else
1772         {
1773           if (!es_write_hexstring (fp, p, (nbits + 7)/8, 0, &nwritten))
1774             n += nwritten;
1775         }
1776     }
1777   else
1778     {
1779       unsigned char *buffer;
1780       size_t buflen;
1781
1782       if (gcry_mpi_aprint (GCRYMPI_FMT_USG, &buffer, &buflen, a))
1783         BUG ();
1784       if (!es_write_hexstring (fp, buffer, buflen, 0, &nwritten))
1785         n += nwritten;
1786       gcry_free (buffer);
1787     }
1788   return n;
1789 }
1790
1791
1792 /* pkey[1] or skey[1] is Q for ECDSA, which is an uncompressed point,
1793    i.e.  04 <x> <y> */
1794 unsigned int
1795 ecdsa_qbits_from_Q (unsigned int qbits)
1796 {
1797   if ((qbits%8) > 3)
1798     {
1799       log_error (_("ECDSA public key is expected to be in SEC encoding "
1800                    "multiple of 8 bits\n"));
1801       return 0;
1802     }
1803   qbits -= qbits%8;
1804   qbits /= 2;
1805   return qbits;
1806 }
1807
1808
1809 /* Ignore signatures and certifications made over certain digest
1810  * algorithms by default, MD5 is considered weak.  This allows users
1811  * to deprecate support for other algorithms as well.
1812  */
1813 void
1814 additional_weak_digest (const char* digestname)
1815 {
1816   struct weakhash *weak = NULL;
1817   const enum gcry_md_algos algo = string_to_digest_algo(digestname);
1818
1819   if (algo == GCRY_MD_NONE)
1820     {
1821       log_error (_("unknown weak digest '%s'\n"), digestname);
1822       return;
1823     }
1824
1825   /* Check to ensure it's not already present.  */
1826   for (weak = opt.weak_digests; weak; weak = weak->next)
1827     if (algo == weak->algo)
1828       return;
1829
1830   /* Add it to the head of the list.  */
1831   weak = xmalloc(sizeof(*weak));
1832   weak->algo = algo;
1833   weak->rejection_shown = 0;
1834   weak->next = opt.weak_digests;
1835   opt.weak_digests = weak;
1836 }