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