spelling: Fix "synchronize"
[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 # define WIN32_LEAN_AND_MEAN 1
46 # include <winsock2.h>
47 #endif
48 #include <windows.h>
49 #include <shlobj.h>
50 #ifndef CSIDL_APPDATA
51 #define CSIDL_APPDATA 0x001a
52 #endif
53 #ifndef CSIDL_LOCAL_APPDATA
54 #define CSIDL_LOCAL_APPDATA 0x001c
55 #endif
56 #ifndef CSIDL_FLAG_CREATE
57 #define CSIDL_FLAG_CREATE 0x8000
58 #endif
59 #endif /*HAVE_W32_SYSTEM*/
60
61 #include "gpg.h"
62 #ifdef HAVE_W32_SYSTEM
63 # include "../common/status.h"
64 #endif /*HAVE_W32_SYSTEM*/
65 #include "../common/util.h"
66 #include "main.h"
67 #include "photoid.h"
68 #include "options.h"
69 #include "call-agent.h"
70 #include "../common/i18n.h"
71 #include "../common/zb32.h"
72
73
74 /* FIXME: Libgcrypt 1.9 will support EAX.  Until we kame this a
75  * requirement we hardwire the enum used for EAX.  */
76 #define MY_GCRY_CIPHER_MODE_EAX 14
77
78
79 #ifdef ENABLE_SELINUX_HACKS
80 /* A object and a global variable to keep track of files marked as
81    secured. */
82 struct secured_file_item
83 {
84   struct secured_file_item *next;
85   ino_t ino;
86   dev_t dev;
87 };
88 static struct secured_file_item *secured_files;
89 #endif /*ENABLE_SELINUX_HACKS*/
90
91
92
93
94 /* For the sake of SELinux we want to restrict access through gpg to
95    certain files we keep under our own control.  This function
96    registers such a file and is_secured_file may then be used to
97    check whether a file has ben registered as secured. */
98 void
99 register_secured_file (const char *fname)
100 {
101 #ifdef ENABLE_SELINUX_HACKS
102   struct stat buf;
103   struct secured_file_item *sf;
104
105   /* Note that we stop immediately if something goes wrong here. */
106   if (stat (fname, &buf))
107     log_fatal (_("fstat of '%s' failed in %s: %s\n"), fname,
108                "register_secured_file", strerror (errno));
109 /*   log_debug ("registering '%s' i=%lu.%lu\n", fname, */
110 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
111   for (sf=secured_files; sf; sf = sf->next)
112     {
113       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
114         return; /* Already registered.  */
115     }
116
117   sf = xmalloc (sizeof *sf);
118   sf->ino = buf.st_ino;
119   sf->dev = buf.st_dev;
120   sf->next = secured_files;
121   secured_files = sf;
122 #else /*!ENABLE_SELINUX_HACKS*/
123   (void)fname;
124 #endif /*!ENABLE_SELINUX_HACKS*/
125 }
126
127 /* Remove a file registered as secure. */
128 void
129 unregister_secured_file (const char *fname)
130 {
131 #ifdef ENABLE_SELINUX_HACKS
132   struct stat buf;
133   struct secured_file_item *sf, *sfprev;
134
135   if (stat (fname, &buf))
136     {
137       log_error (_("fstat of '%s' failed in %s: %s\n"), fname,
138                  "unregister_secured_file", strerror (errno));
139       return;
140     }
141 /*   log_debug ("unregistering '%s' i=%lu.%lu\n", fname,  */
142 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
143   for (sfprev=NULL,sf=secured_files; sf; sfprev=sf, sf = sf->next)
144     {
145       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
146         {
147           if (sfprev)
148             sfprev->next = sf->next;
149           else
150             secured_files = sf->next;
151           xfree (sf);
152           return;
153         }
154     }
155 #else /*!ENABLE_SELINUX_HACKS*/
156   (void)fname;
157 #endif /*!ENABLE_SELINUX_HACKS*/
158 }
159
160 /* Return true if FD is corresponds to a secured file.  Using -1 for
161    FS is allowed and will return false. */
162 int
163 is_secured_file (int fd)
164 {
165 #ifdef ENABLE_SELINUX_HACKS
166   struct stat buf;
167   struct secured_file_item *sf;
168
169   if (fd == -1)
170     return 0; /* No file descriptor so it can't be secured either.  */
171
172   /* Note that we print out a error here and claim that a file is
173      secure if something went wrong. */
174   if (fstat (fd, &buf))
175     {
176       log_error (_("fstat(%d) failed in %s: %s\n"), fd,
177                  "is_secured_file", strerror (errno));
178       return 1;
179     }
180 /*   log_debug ("is_secured_file (%d) i=%lu.%lu\n", fd, */
181 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
182   for (sf=secured_files; sf; sf = sf->next)
183     {
184       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
185         return 1; /* Yes.  */
186     }
187 #else /*!ENABLE_SELINUX_HACKS*/
188   (void)fd;
189 #endif /*!ENABLE_SELINUX_HACKS*/
190   return 0; /* No. */
191 }
192
193 /* Return true if FNAME is corresponds to a secured file.  Using NULL,
194    "" or "-" for FS is allowed and will return false. This function is
195    used before creating a file, thus it won't fail if the file does
196    not exist. */
197 int
198 is_secured_filename (const char *fname)
199 {
200 #ifdef ENABLE_SELINUX_HACKS
201   struct stat buf;
202   struct secured_file_item *sf;
203
204   if (iobuf_is_pipe_filename (fname) || !*fname)
205     return 0;
206
207   /* Note that we print out a error here and claim that a file is
208      secure if something went wrong. */
209   if (stat (fname, &buf))
210     {
211       if (errno == ENOENT || errno == EPERM || errno == EACCES)
212         return 0;
213       log_error (_("fstat of '%s' failed in %s: %s\n"), fname,
214                  "is_secured_filename", strerror (errno));
215       return 1;
216     }
217 /*   log_debug ("is_secured_filename (%s) i=%lu.%lu\n", fname, */
218 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
219   for (sf=secured_files; sf; sf = sf->next)
220     {
221       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
222         return 1; /* Yes.  */
223     }
224 #else /*!ENABLE_SELINUX_HACKS*/
225   (void)fname;
226 #endif /*!ENABLE_SELINUX_HACKS*/
227   return 0; /* No. */
228 }
229
230
231
232 u16
233 checksum_u16( unsigned n )
234 {
235     u16 a;
236
237     a  = (n >> 8) & 0xff;
238     a += n & 0xff;
239     return a;
240 }
241
242
243 u16
244 checksum( byte *p, unsigned n )
245 {
246     u16 a;
247
248     for(a=0; n; n-- )
249         a += *p++;
250     return a;
251 }
252
253 u16
254 checksum_mpi (gcry_mpi_t a)
255 {
256   u16 csum;
257   byte *buffer;
258   size_t nbytes;
259
260   if ( gcry_mpi_print (GCRYMPI_FMT_PGP, NULL, 0, &nbytes, a) )
261     BUG ();
262   /* Fixme: For numbers not in secure memory we should use a stack
263    * based buffer and only allocate a larger one if mpi_print returns
264    * an error. */
265   buffer = (gcry_is_secure(a)?
266             gcry_xmalloc_secure (nbytes) : gcry_xmalloc (nbytes));
267   if ( gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes, NULL, a) )
268     BUG ();
269   csum = checksum (buffer, nbytes);
270   xfree (buffer);
271   return csum;
272 }
273
274
275 void
276 print_pubkey_algo_note (pubkey_algo_t algo)
277 {
278   if(algo >= 100 && algo <= 110)
279     {
280       static int warn=0;
281       if(!warn)
282         {
283           warn=1;
284           es_fflush (es_stdout);
285           log_info (_("WARNING: using experimental public key algorithm %s\n"),
286                     openpgp_pk_algo_name (algo));
287         }
288     }
289   else if (algo == PUBKEY_ALGO_ELGAMAL)
290     {
291       es_fflush (es_stdout);
292       log_info (_("WARNING: Elgamal sign+encrypt keys are deprecated\n"));
293     }
294 }
295
296 void
297 print_cipher_algo_note (cipher_algo_t algo)
298 {
299   if(algo >= 100 && algo <= 110)
300     {
301       static int warn=0;
302       if(!warn)
303         {
304           warn=1;
305           es_fflush (es_stdout);
306           log_info (_("WARNING: using experimental cipher algorithm %s\n"),
307                     openpgp_cipher_algo_name (algo));
308         }
309     }
310 }
311
312 void
313 print_digest_algo_note (digest_algo_t algo)
314 {
315   const enum gcry_md_algos galgo = map_md_openpgp_to_gcry (algo);
316   const struct weakhash *weak;
317
318   if(algo >= 100 && algo <= 110)
319     {
320       static int warn=0;
321       if(!warn)
322         {
323           warn=1;
324           es_fflush (es_stdout);
325           log_info (_("WARNING: using experimental digest algorithm %s\n"),
326                     gcry_md_algo_name (galgo));
327         }
328     }
329   else
330       for (weak = opt.weak_digests; weak != NULL; weak = weak->next)
331         if (weak->algo == galgo)
332           {
333             es_fflush (es_stdout);
334             log_info (_("WARNING: digest algorithm %s is deprecated\n"),
335                       gcry_md_algo_name (galgo));
336           }
337 }
338
339
340 void
341 print_digest_rejected_note (enum gcry_md_algos algo)
342 {
343   struct weakhash* weak;
344   int show = 1;
345   for (weak = opt.weak_digests; weak; weak = weak->next)
346     if (weak->algo == algo)
347       {
348         if (weak->rejection_shown)
349           show = 0;
350         else
351           weak->rejection_shown = 1;
352         break;
353       }
354
355   if (show)
356     {
357       es_fflush (es_stdout);
358       log_info
359         (_("Note: signatures using the %s algorithm are rejected\n"),
360          gcry_md_algo_name(algo));
361     }
362 }
363
364
365 /* Print a message
366  *  "(reported error: %s)\n
367  * in verbose mode to further explain an error.  If the error code has
368  * the value IGNORE_EC no message is printed.  A message is also not
369  * printed if ERR is 0.  */
370 void
371 print_reported_error (gpg_error_t err, gpg_err_code_t ignore_ec)
372 {
373   if (!opt.verbose)
374     return;
375
376   if (!gpg_err_code (err))
377     ;
378   else if (gpg_err_code (err) == ignore_ec)
379     ;
380   else if (gpg_err_source (err) == GPG_ERR_SOURCE_DEFAULT)
381     log_info (_("(reported error: %s)\n"),
382               gpg_strerror (err));
383   else
384     log_info (_("(reported error: %s <%s>)\n"),
385               gpg_strerror (err), gpg_strsource (err));
386
387 }
388
389
390 /* Print a message
391  *   "(further info: %s)\n
392  * in verbose mode to further explain an error.  That message is
393  * intended to help debug a problem and should not be translated.
394  */
395 void
396 print_further_info (const char *format, ...)
397 {
398   va_list arg_ptr;
399
400   if (!opt.verbose)
401     return;
402
403   log_info (_("(further info: "));
404   va_start (arg_ptr, format);
405   log_logv (GPGRT_LOGLVL_CONT, format, arg_ptr);
406   va_end (arg_ptr);
407   log_printf (")\n");
408 }
409
410
411 /* Map OpenPGP algo numbers to those used by Libgcrypt.  We need to do
412    this for algorithms we implemented in Libgcrypt after they become
413    part of OpenPGP.  */
414 enum gcry_cipher_algos
415 map_cipher_openpgp_to_gcry (cipher_algo_t algo)
416 {
417   switch (algo)
418     {
419     case CIPHER_ALGO_NONE:        return GCRY_CIPHER_NONE;
420
421 #ifdef GPG_USE_IDEA
422     case CIPHER_ALGO_IDEA:        return GCRY_CIPHER_IDEA;
423 #else
424     case CIPHER_ALGO_IDEA:        return 0;
425 #endif
426
427     case CIPHER_ALGO_3DES:        return GCRY_CIPHER_3DES;
428
429 #ifdef GPG_USE_CAST5
430     case CIPHER_ALGO_CAST5:       return GCRY_CIPHER_CAST5;
431 #else
432     case CIPHER_ALGO_CAST5:       return 0;
433 #endif
434
435 #ifdef GPG_USE_BLOWFISH
436     case CIPHER_ALGO_BLOWFISH:    return GCRY_CIPHER_BLOWFISH;
437 #else
438     case CIPHER_ALGO_BLOWFISH:    return 0;
439 #endif
440
441 #ifdef GPG_USE_AES128
442     case CIPHER_ALGO_AES:         return GCRY_CIPHER_AES;
443 #else
444     case CIPHER_ALGO_AES:         return 0;
445 #endif
446
447 #ifdef GPG_USE_AES192
448     case CIPHER_ALGO_AES192:      return GCRY_CIPHER_AES192;
449 #else
450     case CIPHER_ALGO_AES192:      return 0;
451 #endif
452
453 #ifdef GPG_USE_AES256
454     case CIPHER_ALGO_AES256:      return GCRY_CIPHER_AES256;
455 #else
456     case CIPHER_ALGO_AES256:      return 0;
457 #endif
458
459 #ifdef GPG_USE_TWOFISH
460     case CIPHER_ALGO_TWOFISH:     return GCRY_CIPHER_TWOFISH;
461 #else
462     case CIPHER_ALGO_TWOFISH:     return 0;
463 #endif
464
465 #ifdef GPG_USE_CAMELLIA128
466     case CIPHER_ALGO_CAMELLIA128: return GCRY_CIPHER_CAMELLIA128;
467 #else
468     case CIPHER_ALGO_CAMELLIA128: return 0;
469 #endif
470
471 #ifdef GPG_USE_CAMELLIA192
472     case CIPHER_ALGO_CAMELLIA192: return GCRY_CIPHER_CAMELLIA192;
473 #else
474     case CIPHER_ALGO_CAMELLIA192: return 0;
475 #endif
476
477 #ifdef GPG_USE_CAMELLIA256
478     case CIPHER_ALGO_CAMELLIA256: return GCRY_CIPHER_CAMELLIA256;
479 #else
480     case CIPHER_ALGO_CAMELLIA256: return 0;
481 #endif
482     default: return 0;
483     }
484 }
485
486 /* The inverse function of above.  */
487 static cipher_algo_t
488 map_cipher_gcry_to_openpgp (enum gcry_cipher_algos algo)
489 {
490   switch (algo)
491     {
492     case GCRY_CIPHER_NONE:        return CIPHER_ALGO_NONE;
493     case GCRY_CIPHER_IDEA:        return CIPHER_ALGO_IDEA;
494     case GCRY_CIPHER_3DES:        return CIPHER_ALGO_3DES;
495     case GCRY_CIPHER_CAST5:       return CIPHER_ALGO_CAST5;
496     case GCRY_CIPHER_BLOWFISH:    return CIPHER_ALGO_BLOWFISH;
497     case GCRY_CIPHER_AES:         return CIPHER_ALGO_AES;
498     case GCRY_CIPHER_AES192:      return CIPHER_ALGO_AES192;
499     case GCRY_CIPHER_AES256:      return CIPHER_ALGO_AES256;
500     case GCRY_CIPHER_TWOFISH:     return CIPHER_ALGO_TWOFISH;
501     case GCRY_CIPHER_CAMELLIA128: return CIPHER_ALGO_CAMELLIA128;
502     case GCRY_CIPHER_CAMELLIA192: return CIPHER_ALGO_CAMELLIA192;
503     case GCRY_CIPHER_CAMELLIA256: return CIPHER_ALGO_CAMELLIA256;
504     default: return 0;
505     }
506 }
507
508 /* Map Gcrypt public key algorithm numbers to those used by OpenPGP.
509    FIXME: This mapping is used at only two places - we should get rid
510    of it.  */
511 pubkey_algo_t
512 map_pk_gcry_to_openpgp (enum gcry_pk_algos algo)
513 {
514   switch (algo)
515     {
516     case GCRY_PK_EDDSA:  return PUBKEY_ALGO_EDDSA;
517     case GCRY_PK_ECDSA:  return PUBKEY_ALGO_ECDSA;
518     case GCRY_PK_ECDH:   return PUBKEY_ALGO_ECDH;
519     default: return algo < 110 ? (pubkey_algo_t)algo : 0;
520     }
521 }
522
523
524 /* Return the block length of an OpenPGP cipher algorithm.  */
525 int
526 openpgp_cipher_blocklen (cipher_algo_t algo)
527 {
528   /* We use the numbers from OpenPGP to be sure that we get the right
529      block length.  This is so that the packet parsing code works even
530      for unknown algorithms (for which we assume 8 due to tradition).
531
532      NOTE: If you change the returned blocklen above 16, check
533      the callers because they may use a fixed size buffer of that
534      size. */
535   switch (algo)
536     {
537     case CIPHER_ALGO_AES:
538     case CIPHER_ALGO_AES192:
539     case CIPHER_ALGO_AES256:
540     case CIPHER_ALGO_TWOFISH:
541     case CIPHER_ALGO_CAMELLIA128:
542     case CIPHER_ALGO_CAMELLIA192:
543     case CIPHER_ALGO_CAMELLIA256:
544       return 16;
545
546     default:
547       return 8;
548     }
549 }
550
551 /****************
552  * Wrapper around the libgcrypt function with additional checks on
553  * the OpenPGP constraints for the algo ID.
554  */
555 int
556 openpgp_cipher_test_algo (cipher_algo_t algo)
557 {
558   enum gcry_cipher_algos ga;
559
560   ga = map_cipher_openpgp_to_gcry (algo);
561   if (!ga)
562     return gpg_error (GPG_ERR_CIPHER_ALGO);
563
564   return gcry_cipher_test_algo (ga);
565 }
566
567 /* Map the OpenPGP cipher algorithm whose ID is contained in ALGORITHM to a
568    string representation of the algorithm name.  For unknown algorithm
569    IDs this function returns "?".  */
570 const char *
571 openpgp_cipher_algo_name (cipher_algo_t algo)
572 {
573   switch (algo)
574     {
575     case CIPHER_ALGO_IDEA:        return "IDEA";
576     case CIPHER_ALGO_3DES:        return "3DES";
577     case CIPHER_ALGO_CAST5:       return "CAST5";
578     case CIPHER_ALGO_BLOWFISH:    return "BLOWFISH";
579     case CIPHER_ALGO_AES:         return "AES";
580     case CIPHER_ALGO_AES192:      return "AES192";
581     case CIPHER_ALGO_AES256:      return "AES256";
582     case CIPHER_ALGO_TWOFISH:     return "TWOFISH";
583     case CIPHER_ALGO_CAMELLIA128: return "CAMELLIA128";
584     case CIPHER_ALGO_CAMELLIA192: return "CAMELLIA192";
585     case CIPHER_ALGO_CAMELLIA256: return "CAMELLIA256";
586     case CIPHER_ALGO_NONE:
587     default: return "?";
588     }
589 }
590
591
592 /* Return 0 if ALGO is supported.  Return an error if not. */
593 gpg_error_t
594 openpgp_aead_test_algo (aead_algo_t algo)
595 {
596   /* FIXME: We currently have no easy way to test whether libgcrypt
597    * implements a mode.  The only way we can do this is to open a
598    * cipher context with that mode and close it immediately.  That is
599    * a bit costly.  So we look at the libgcrypt version and assume
600    * nothing has been patched out.  */
601   switch (algo)
602     {
603     case AEAD_ALGO_NONE:
604       break;
605
606     case AEAD_ALGO_EAX:
607 #if GCRYPT_VERSION_NUMBER < 0x010900
608       break;
609 #else
610       return 0;
611 #endif
612
613     case AEAD_ALGO_OCB:
614       return 0;
615     }
616
617   return gpg_error (GPG_ERR_INV_CIPHER_MODE);
618 }
619
620
621 /* Map the OpenPGP AEAD algorithm with ID ALGO to a string
622  * representation of the algorithm name.  For unknown algorithm IDs
623  * this function returns "?".  */
624 const char *
625 openpgp_aead_algo_name (aead_algo_t algo)
626 {
627   switch (algo)
628     {
629     case AEAD_ALGO_NONE:  break;
630     case AEAD_ALGO_EAX:   return "EAX";
631     case AEAD_ALGO_OCB:   return "OCB";
632     }
633
634   return "?";
635 }
636
637
638 /* Return information for the AEAD algorithm ALGO.  The corresponding
639  * Libgcrypt ciphermode is stored at R_MODE and the required number of
640  * octets for the nonce at R_NONCELEN.  On error and error code is
641  * returned.  Note that the taglen is always 128 bits.  */
642 gpg_error_t
643 openpgp_aead_algo_info (aead_algo_t algo, enum gcry_cipher_modes *r_mode,
644                         unsigned int *r_noncelen)
645 {
646   switch (algo)
647     {
648     case AEAD_ALGO_OCB:
649       *r_mode = GCRY_CIPHER_MODE_OCB;
650       *r_noncelen = 15;
651       break;
652
653     case AEAD_ALGO_EAX:
654       *r_mode = MY_GCRY_CIPHER_MODE_EAX;
655       *r_noncelen = 16;
656       break;
657
658     default:
659       log_error ("unsupported AEAD algo %d\n", algo);
660       return gpg_error (GPG_ERR_INV_CIPHER_MODE);
661     }
662   return 0;
663 }
664
665
666 /* Return 0 if ALGO is a supported OpenPGP public key algorithm.  */
667 int
668 openpgp_pk_test_algo (pubkey_algo_t algo)
669 {
670   return openpgp_pk_test_algo2 (algo, 0);
671 }
672
673
674 /* Return 0 if ALGO is a supported OpenPGP public key algorithm and
675    allows the usage USE.  */
676 int
677 openpgp_pk_test_algo2 (pubkey_algo_t algo, unsigned int use)
678 {
679   enum gcry_pk_algos ga = 0;
680   size_t use_buf = use;
681
682   switch (algo)
683     {
684 #ifdef GPG_USE_RSA
685     case PUBKEY_ALGO_RSA:       ga = GCRY_PK_RSA;   break;
686     case PUBKEY_ALGO_RSA_E:     ga = GCRY_PK_RSA_E; break;
687     case PUBKEY_ALGO_RSA_S:     ga = GCRY_PK_RSA_S; break;
688 #else
689     case PUBKEY_ALGO_RSA:       break;
690     case PUBKEY_ALGO_RSA_E:     break;
691     case PUBKEY_ALGO_RSA_S:     break;
692 #endif
693
694     case PUBKEY_ALGO_ELGAMAL_E: ga = GCRY_PK_ELG;   break;
695     case PUBKEY_ALGO_DSA:       ga = GCRY_PK_DSA;   break;
696
697 #ifdef GPG_USE_ECDH
698     case PUBKEY_ALGO_ECDH:      ga = GCRY_PK_ECC;   break;
699 #else
700     case PUBKEY_ALGO_ECDH:      break;
701 #endif
702
703 #ifdef GPG_USE_ECDSA
704     case PUBKEY_ALGO_ECDSA:     ga = GCRY_PK_ECC;   break;
705 #else
706     case PUBKEY_ALGO_ECDSA:     break;
707 #endif
708
709 #ifdef GPG_USE_EDDSA
710     case PUBKEY_ALGO_EDDSA:     ga = GCRY_PK_ECC;   break;
711 #else
712     case PUBKEY_ALGO_EDDSA:     break;
713 #endif
714
715     case PUBKEY_ALGO_ELGAMAL:
716       /* Don't allow type 20 keys unless in rfc2440 mode.  */
717       if (RFC2440)
718         ga = GCRY_PK_ELG;
719       break;
720
721     default:
722       break;
723     }
724   if (!ga)
725     return gpg_error (GPG_ERR_PUBKEY_ALGO);
726
727   /* Elgamal in OpenPGP used to support signing and Libgcrypt still
728    * does.  However, we removed the signing capability from gpg ages
729    * ago.  This function should reflect this so that errors are thrown
730    * early and not only when we try to sign using Elgamal.  */
731   if (ga == GCRY_PK_ELG && (use & (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)))
732     return gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
733
734   /* Now check whether Libgcrypt has support for the algorithm.  */
735   return gcry_pk_algo_info (ga, GCRYCTL_TEST_ALGO, NULL, &use_buf);
736 }
737
738
739 int
740 openpgp_pk_algo_usage ( int algo )
741 {
742     int use = 0;
743
744     /* They are hardwired in gpg 1.0. */
745     switch ( algo ) {
746       case PUBKEY_ALGO_RSA:
747           use = (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG
748                  | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH);
749           break;
750       case PUBKEY_ALGO_RSA_E:
751       case PUBKEY_ALGO_ECDH:
752           use = PUBKEY_USAGE_ENC;
753           break;
754       case PUBKEY_ALGO_RSA_S:
755           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG;
756           break;
757       case PUBKEY_ALGO_ELGAMAL:
758           if (RFC2440)
759              use = PUBKEY_USAGE_ENC;
760           break;
761       case PUBKEY_ALGO_ELGAMAL_E:
762           use = PUBKEY_USAGE_ENC;
763           break;
764       case PUBKEY_ALGO_DSA:
765           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
766           break;
767       case PUBKEY_ALGO_ECDSA:
768       case PUBKEY_ALGO_EDDSA:
769           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
770       default:
771           break;
772     }
773     return use;
774 }
775
776 /* Map the OpenPGP pubkey algorithm whose ID is contained in ALGO to a
777    string representation of the algorithm name.  For unknown algorithm
778    IDs this function returns "?".  */
779 const char *
780 openpgp_pk_algo_name (pubkey_algo_t algo)
781 {
782   switch (algo)
783     {
784     case PUBKEY_ALGO_RSA:
785     case PUBKEY_ALGO_RSA_E:
786     case PUBKEY_ALGO_RSA_S:     return "RSA";
787     case PUBKEY_ALGO_ELGAMAL:
788     case PUBKEY_ALGO_ELGAMAL_E: return "ELG";
789     case PUBKEY_ALGO_DSA:       return "DSA";
790     case PUBKEY_ALGO_ECDH:      return "ECDH";
791     case PUBKEY_ALGO_ECDSA:     return "ECDSA";
792     case PUBKEY_ALGO_EDDSA:     return "EDDSA";
793     default: return "?";
794     }
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 /*
1205  * Map an AEAD mode string to a an AEAD algorithm number as defined by
1206  * rrc4880bis.  Also support the "An" syntax as used by the preference
1207  * strings.
1208  */
1209 aead_algo_t
1210 string_to_aead_algo (const char *string)
1211 {
1212   int result;
1213
1214   if (!string)
1215     result = 0;
1216   if (!ascii_strcasecmp (string, "EAX"))
1217     result = 1;
1218   else if (!ascii_strcasecmp (string, "OCB"))
1219     result = 2;
1220   else if ((string[0]=='A' || string[0]=='a'))
1221     {
1222       char *endptr;
1223
1224       string++;
1225       result = strtol (string, &endptr, 10);
1226       if (!*string || *endptr || result < 1 || result > 2)
1227         result = 0;
1228     }
1229   else
1230     result = 0;
1231
1232   return result;
1233 }
1234
1235
1236 /*
1237  * Wrapper around gcry_md_map_name to provide a fallback using the
1238  * "Hn" syntax as used by the preference strings.
1239  */
1240 int
1241 string_to_digest_algo (const char *string)
1242 {
1243   int val;
1244
1245   /* FIXME: We should make use of our wrapper function and not assume
1246      that there is a 1 to 1 mapping between OpenPGP and Libgcrypt.  */
1247   val = gcry_md_map_name (string);
1248   if (!val && string && (string[0]=='H' || string[0]=='h'))
1249     {
1250       char *endptr;
1251
1252       string++;
1253       val = strtol (string, &endptr, 10);
1254       if (!*string || *endptr || openpgp_md_test_algo (val))
1255         val = 0;
1256     }
1257
1258   return val;
1259 }
1260
1261
1262
1263 const char *
1264 compress_algo_to_string(int algo)
1265 {
1266   const char *s=NULL;
1267
1268   switch(algo)
1269     {
1270     case COMPRESS_ALGO_NONE:
1271       s=_("Uncompressed");
1272       break;
1273
1274     case COMPRESS_ALGO_ZIP:
1275       s="ZIP";
1276       break;
1277
1278     case COMPRESS_ALGO_ZLIB:
1279       s="ZLIB";
1280       break;
1281
1282 #ifdef HAVE_BZIP2
1283     case COMPRESS_ALGO_BZIP2:
1284       s="BZIP2";
1285       break;
1286 #endif
1287     }
1288
1289   return s;
1290 }
1291
1292 int
1293 string_to_compress_algo(const char *string)
1294 {
1295   /* TRANSLATORS: See doc/TRANSLATE about this string. */
1296   if(match_multistr(_("uncompressed|none"),string))
1297     return 0;
1298   else if(ascii_strcasecmp(string,"uncompressed")==0)
1299     return 0;
1300   else if(ascii_strcasecmp(string,"none")==0)
1301     return 0;
1302   else if(ascii_strcasecmp(string,"zip")==0)
1303     return 1;
1304   else if(ascii_strcasecmp(string,"zlib")==0)
1305     return 2;
1306 #ifdef HAVE_BZIP2
1307   else if(ascii_strcasecmp(string,"bzip2")==0)
1308     return 3;
1309 #endif
1310   else if(ascii_strcasecmp(string,"z0")==0)
1311     return 0;
1312   else if(ascii_strcasecmp(string,"z1")==0)
1313     return 1;
1314   else if(ascii_strcasecmp(string,"z2")==0)
1315     return 2;
1316 #ifdef HAVE_BZIP2
1317   else if(ascii_strcasecmp(string,"z3")==0)
1318     return 3;
1319 #endif
1320   else
1321     return -1;
1322 }
1323
1324 int
1325 check_compress_algo(int algo)
1326 {
1327   switch (algo)
1328     {
1329     case 0: return 0;
1330 #ifdef HAVE_ZIP
1331     case 1:
1332     case 2: return 0;
1333 #endif
1334 #ifdef HAVE_BZIP2
1335     case 3: return 0;
1336 #endif
1337     default: return GPG_ERR_COMPR_ALGO;
1338     }
1339 }
1340
1341 int
1342 default_cipher_algo(void)
1343 {
1344   if(opt.def_cipher_algo)
1345     return opt.def_cipher_algo;
1346   else if(opt.personal_cipher_prefs)
1347     return opt.personal_cipher_prefs[0].value;
1348   else
1349     return opt.s2k_cipher_algo;
1350 }
1351
1352
1353 aead_algo_t
1354 default_aead_algo(void)
1355 {
1356   if(opt.def_aead_algo)
1357     return opt.def_aead_algo;
1358   else if(opt.personal_aead_prefs)
1359     return opt.personal_aead_prefs[0].value;
1360   else
1361     return DEFAULT_AEAD_ALGO;
1362 }
1363
1364 /* There is no default_digest_algo function, but see
1365    sign.c:hash_for() */
1366
1367 int
1368 default_compress_algo(void)
1369 {
1370   if(opt.compress_algo!=-1)
1371     return opt.compress_algo;
1372   else if(opt.personal_compress_prefs)
1373     return opt.personal_compress_prefs[0].value;
1374   else
1375     return DEFAULT_COMPRESS_ALGO;
1376 }
1377
1378
1379 void
1380 compliance_failure(void)
1381 {
1382   char *ver="???";
1383
1384   switch(opt.compliance)
1385     {
1386     case CO_GNUPG:
1387       ver="GnuPG";
1388       break;
1389
1390     case CO_RFC4880:
1391       ver="OpenPGP";
1392       break;
1393
1394     case CO_RFC2440:
1395       ver="OpenPGP (older)";
1396       break;
1397
1398     case CO_PGP7:
1399       ver="PGP 7.x";
1400       break;
1401
1402     case CO_PGP8:
1403       ver="PGP 8.x";
1404       break;
1405
1406     case CO_DE_VS:
1407       ver="DE-VS applications";
1408       break;
1409     }
1410
1411   log_info(_("this message may not be usable by %s\n"),ver);
1412   opt.compliance=CO_GNUPG;
1413 }
1414
1415 /* Break a string into successive option pieces.  Accepts single word
1416    options and key=value argument options. */
1417 char *
1418 optsep(char **stringp)
1419 {
1420   char *tok,*end;
1421
1422   tok=*stringp;
1423   if(tok)
1424     {
1425       end=strpbrk(tok," ,=");
1426       if(end)
1427         {
1428           int sawequals=0;
1429           char *ptr=end;
1430
1431           /* what we need to do now is scan along starting with *end,
1432              If the next character we see (ignoring spaces) is an =
1433              sign, then there is an argument. */
1434
1435           while(*ptr)
1436             {
1437               if(*ptr=='=')
1438                 sawequals=1;
1439               else if(*ptr!=' ')
1440                 break;
1441               ptr++;
1442             }
1443
1444           /* There is an argument, so grab that too.  At this point,
1445              ptr points to the first character of the argument. */
1446           if(sawequals)
1447             {
1448               /* Is it a quoted argument? */
1449               if(*ptr=='"')
1450                 {
1451                   ptr++;
1452                   end=strchr(ptr,'"');
1453                   if(end)
1454                     end++;
1455                 }
1456               else
1457                 end=strpbrk(ptr," ,");
1458             }
1459
1460           if(end && *end)
1461             {
1462               *end='\0';
1463               *stringp=end+1;
1464             }
1465           else
1466             *stringp=NULL;
1467         }
1468       else
1469         *stringp=NULL;
1470     }
1471
1472   return tok;
1473 }
1474
1475 /* Breaks an option value into key and value.  Returns NULL if there
1476    is no value.  Note that "string" is modified to remove the =value
1477    part. */
1478 char *
1479 argsplit(char *string)
1480 {
1481   char *equals,*arg=NULL;
1482
1483   equals=strchr(string,'=');
1484   if(equals)
1485     {
1486       char *quote,*space;
1487
1488       *equals='\0';
1489       arg=equals+1;
1490
1491       /* Quoted arg? */
1492       quote=strchr(arg,'"');
1493       if(quote)
1494         {
1495           arg=quote+1;
1496
1497           quote=strchr(arg,'"');
1498           if(quote)
1499             *quote='\0';
1500         }
1501       else
1502         {
1503           size_t spaces;
1504
1505           /* Trim leading spaces off of the arg */
1506           spaces=strspn(arg," ");
1507           arg+=spaces;
1508         }
1509
1510       /* Trim tailing spaces off of the tag */
1511       space=strchr(string,' ');
1512       if(space)
1513         *space='\0';
1514     }
1515
1516   return arg;
1517 }
1518
1519 /* Return the length of the initial token, leaving off any
1520    argument. */
1521 static size_t
1522 optlen(const char *s)
1523 {
1524   char *end=strpbrk(s," =");
1525
1526   if(end)
1527     return end-s;
1528   else
1529     return strlen(s);
1530 }
1531
1532
1533 /* Note: This function returns true on success.  */
1534 int
1535 parse_options(char *str,unsigned int *options,
1536               struct parse_options *opts,int noisy)
1537 {
1538   char *tok;
1539
1540   if (str && !strcmp (str, "help"))
1541     {
1542       int i,maxlen=0;
1543
1544       /* Figure out the longest option name so we can line these up
1545          neatly. */
1546       for(i=0;opts[i].name;i++)
1547         if(opts[i].help && maxlen<strlen(opts[i].name))
1548           maxlen=strlen(opts[i].name);
1549
1550       for(i=0;opts[i].name;i++)
1551         if(opts[i].help)
1552           es_printf("%s%*s%s\n",opts[i].name,
1553                     maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1554
1555       g10_exit(0);
1556     }
1557
1558   while((tok=optsep(&str)))
1559     {
1560       int i,rev=0;
1561       char *otok=tok;
1562
1563       if(tok[0]=='\0')
1564         continue;
1565
1566       if(ascii_strncasecmp("no-",tok,3)==0)
1567         {
1568           rev=1;
1569           tok+=3;
1570         }
1571
1572       for(i=0;opts[i].name;i++)
1573         {
1574           size_t toklen=optlen(tok);
1575
1576           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1577             {
1578               /* We have a match, but it might be incomplete */
1579               if(toklen!=strlen(opts[i].name))
1580                 {
1581                   int j;
1582
1583                   for(j=i+1;opts[j].name;j++)
1584                     {
1585                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1586                         {
1587                           if(noisy)
1588                             log_info(_("ambiguous option '%s'\n"),otok);
1589                           return 0;
1590                         }
1591                     }
1592                 }
1593
1594               if(rev)
1595                 {
1596                   *options&=~opts[i].bit;
1597                   if(opts[i].value)
1598                     *opts[i].value=NULL;
1599                 }
1600               else
1601                 {
1602                   *options|=opts[i].bit;
1603                   if(opts[i].value)
1604                     *opts[i].value=argsplit(tok);
1605                 }
1606               break;
1607             }
1608         }
1609
1610       if(!opts[i].name)
1611         {
1612           if(noisy)
1613             log_info(_("unknown option '%s'\n"),otok);
1614           return 0;
1615         }
1616     }
1617
1618   return 1;
1619 }
1620
1621
1622 /* Similar to access(2), but uses PATH to find the file. */
1623 int
1624 path_access(const char *file,int mode)
1625 {
1626   char *envpath;
1627   int ret=-1;
1628
1629   envpath=getenv("PATH");
1630
1631   if(!envpath
1632 #ifdef HAVE_DRIVE_LETTERS
1633      || (((file[0]>='A' && file[0]<='Z')
1634           || (file[0]>='a' && file[0]<='z'))
1635          && file[1]==':')
1636 #else
1637      || file[0]=='/'
1638 #endif
1639      )
1640     return access(file,mode);
1641   else
1642     {
1643       /* At least as large as, but most often larger than we need. */
1644       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1645       char *split,*item,*path=xstrdup(envpath);
1646
1647       split=path;
1648
1649       while((item=strsep(&split,PATHSEP_S)))
1650         {
1651           strcpy(buffer,item);
1652           strcat(buffer,"/");
1653           strcat(buffer,file);
1654           ret=access(buffer,mode);
1655           if(ret==0)
1656             break;
1657         }
1658
1659       xfree(path);
1660       xfree(buffer);
1661     }
1662
1663   return ret;
1664 }
1665
1666
1667 \f
1668 /* Return the number of public key parameters as used by OpenPGP.  */
1669 int
1670 pubkey_get_npkey (pubkey_algo_t algo)
1671 {
1672   switch (algo)
1673     {
1674     case PUBKEY_ALGO_RSA:
1675     case PUBKEY_ALGO_RSA_E:
1676     case PUBKEY_ALGO_RSA_S:     return 2;
1677     case PUBKEY_ALGO_ELGAMAL_E: return 3;
1678     case PUBKEY_ALGO_DSA:       return 4;
1679     case PUBKEY_ALGO_ECDH:      return 3;
1680     case PUBKEY_ALGO_ECDSA:     return 2;
1681     case PUBKEY_ALGO_ELGAMAL:   return 3;
1682     case PUBKEY_ALGO_EDDSA:     return 2;
1683     default: return 0;
1684     }
1685 }
1686
1687
1688 /* Return the number of secret key parameters as used by OpenPGP.  */
1689 int
1690 pubkey_get_nskey (pubkey_algo_t algo)
1691 {
1692   switch (algo)
1693     {
1694     case PUBKEY_ALGO_RSA:
1695     case PUBKEY_ALGO_RSA_E:
1696     case PUBKEY_ALGO_RSA_S:     return 6;
1697     case PUBKEY_ALGO_ELGAMAL_E: return 4;
1698     case PUBKEY_ALGO_DSA:       return 5;
1699     case PUBKEY_ALGO_ECDH:      return 4;
1700     case PUBKEY_ALGO_ECDSA:     return 3;
1701     case PUBKEY_ALGO_ELGAMAL:   return 4;
1702     case PUBKEY_ALGO_EDDSA:     return 3;
1703     default: return 0;
1704     }
1705 }
1706
1707 /* Temporary helper. */
1708 int
1709 pubkey_get_nsig (pubkey_algo_t algo)
1710 {
1711   switch (algo)
1712     {
1713     case PUBKEY_ALGO_RSA:
1714     case PUBKEY_ALGO_RSA_E:
1715     case PUBKEY_ALGO_RSA_S:     return 1;
1716     case PUBKEY_ALGO_ELGAMAL_E: return 0;
1717     case PUBKEY_ALGO_DSA:       return 2;
1718     case PUBKEY_ALGO_ECDH:      return 0;
1719     case PUBKEY_ALGO_ECDSA:     return 2;
1720     case PUBKEY_ALGO_ELGAMAL:   return 2;
1721     case PUBKEY_ALGO_EDDSA:     return 2;
1722     default: return 0;
1723     }
1724 }
1725
1726
1727 /* Temporary helper. */
1728 int
1729 pubkey_get_nenc (pubkey_algo_t algo)
1730 {
1731   switch (algo)
1732     {
1733     case PUBKEY_ALGO_RSA:
1734     case PUBKEY_ALGO_RSA_E:
1735     case PUBKEY_ALGO_RSA_S:     return 1;
1736     case PUBKEY_ALGO_ELGAMAL_E: return 2;
1737     case PUBKEY_ALGO_DSA:       return 0;
1738     case PUBKEY_ALGO_ECDH:      return 2;
1739     case PUBKEY_ALGO_ECDSA:     return 0;
1740     case PUBKEY_ALGO_ELGAMAL:   return 2;
1741     case PUBKEY_ALGO_EDDSA:     return 0;
1742     default: return 0;
1743     }
1744 }
1745
1746
1747 /* Temporary helper. */
1748 unsigned int
1749 pubkey_nbits( int algo, gcry_mpi_t *key )
1750 {
1751   int rc, nbits;
1752   gcry_sexp_t sexp;
1753
1754   if (algo == PUBKEY_ALGO_DSA
1755       && key[0] && key[1] && key[2] && key[3])
1756     {
1757       rc = gcry_sexp_build (&sexp, NULL,
1758                             "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1759                             key[0], key[1], key[2], key[3] );
1760     }
1761   else if ((algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E)
1762            && key[0] && key[1] && key[2])
1763     {
1764       rc = gcry_sexp_build (&sexp, NULL,
1765                             "(public-key(elg(p%m)(g%m)(y%m)))",
1766                             key[0], key[1], key[2] );
1767     }
1768   else if (is_RSA (algo)
1769            && key[0] && key[1])
1770     {
1771       rc = gcry_sexp_build (&sexp, NULL,
1772                             "(public-key(rsa(n%m)(e%m)))",
1773                             key[0], key[1] );
1774     }
1775   else if ((algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_ECDH
1776             || algo == PUBKEY_ALGO_EDDSA)
1777            && key[0] && key[1])
1778     {
1779       char *curve = openpgp_oid_to_str (key[0]);
1780       if (!curve)
1781         rc = gpg_error_from_syserror ();
1782       else
1783         {
1784           rc = gcry_sexp_build (&sexp, NULL,
1785                                 "(public-key(ecc(curve%s)(q%m)))",
1786                                 curve, key[1]);
1787           xfree (curve);
1788         }
1789     }
1790   else
1791     return 0;
1792
1793   if (rc)
1794     BUG ();
1795
1796   nbits = gcry_pk_get_nbits (sexp);
1797   gcry_sexp_release (sexp);
1798   return nbits;
1799 }
1800
1801
1802
1803 int
1804 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1805 {
1806   int n = 0;
1807   size_t nwritten;
1808
1809   if (!a)
1810     return es_fprintf (fp, "[MPI_NULL]");
1811   if (!mode)
1812     {
1813       unsigned int n1;
1814       n1 = gcry_mpi_get_nbits(a);
1815       n += es_fprintf (fp, "[%u bits]", n1);
1816     }
1817   else if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
1818     {
1819       unsigned int nbits;
1820       unsigned char *p = gcry_mpi_get_opaque (a, &nbits);
1821       if (!p)
1822         n += es_fprintf (fp, "[invalid opaque value]");
1823       else
1824         {
1825           if (!es_write_hexstring (fp, p, (nbits + 7)/8, 0, &nwritten))
1826             n += nwritten;
1827         }
1828     }
1829   else
1830     {
1831       unsigned char *buffer;
1832       size_t buflen;
1833
1834       if (gcry_mpi_aprint (GCRYMPI_FMT_USG, &buffer, &buflen, a))
1835         BUG ();
1836       if (!es_write_hexstring (fp, buffer, buflen, 0, &nwritten))
1837         n += nwritten;
1838       gcry_free (buffer);
1839     }
1840   return n;
1841 }
1842
1843
1844 /* pkey[1] or skey[1] is Q for ECDSA, which is an uncompressed point,
1845    i.e.  04 <x> <y> */
1846 unsigned int
1847 ecdsa_qbits_from_Q (unsigned int qbits)
1848 {
1849   if ((qbits%8) > 3)
1850     {
1851       log_error (_("ECDSA public key is expected to be in SEC encoding "
1852                    "multiple of 8 bits\n"));
1853       return 0;
1854     }
1855   qbits -= qbits%8;
1856   qbits /= 2;
1857   return qbits;
1858 }
1859
1860
1861 /* Ignore signatures and certifications made over certain digest
1862  * algorithms by default, MD5 is considered weak.  This allows users
1863  * to deprecate support for other algorithms as well.
1864  */
1865 void
1866 additional_weak_digest (const char* digestname)
1867 {
1868   struct weakhash *weak = NULL;
1869   const enum gcry_md_algos algo = string_to_digest_algo(digestname);
1870
1871   if (algo == GCRY_MD_NONE)
1872     {
1873       log_error (_("unknown weak digest '%s'\n"), digestname);
1874       return;
1875     }
1876
1877   /* Check to ensure it's not already present.  */
1878   for (weak = opt.weak_digests; weak; weak = weak->next)
1879     if (algo == weak->algo)
1880       return;
1881
1882   /* Add it to the head of the list.  */
1883   weak = xmalloc(sizeof(*weak));
1884   weak->algo = algo;
1885   weak->rejection_shown = 0;
1886   weak->next = opt.weak_digests;
1887   opt.weak_digests = weak;
1888 }