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