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