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