g10: Fix print_pubkey_info new line output.
[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 constraints 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       /* Don'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_PGP7:
1391       ver="PGP 7.x";
1392       break;
1393
1394     case CO_PGP8:
1395       ver="PGP 8.x";
1396       break;
1397
1398     case CO_DE_VS:
1399       ver="DE-VS applications";
1400       break;
1401     }
1402
1403   log_info(_("this message may not be usable by %s\n"),ver);
1404   opt.compliance=CO_GNUPG;
1405 }
1406
1407 /* Break a string into successive option pieces.  Accepts single word
1408    options and key=value argument options. */
1409 char *
1410 optsep(char **stringp)
1411 {
1412   char *tok,*end;
1413
1414   tok=*stringp;
1415   if(tok)
1416     {
1417       end=strpbrk(tok," ,=");
1418       if(end)
1419         {
1420           int sawequals=0;
1421           char *ptr=end;
1422
1423           /* what we need to do now is scan along starting with *end,
1424              If the next character we see (ignoring spaces) is an =
1425              sign, then there is an argument. */
1426
1427           while(*ptr)
1428             {
1429               if(*ptr=='=')
1430                 sawequals=1;
1431               else if(*ptr!=' ')
1432                 break;
1433               ptr++;
1434             }
1435
1436           /* There is an argument, so grab that too.  At this point,
1437              ptr points to the first character of the argument. */
1438           if(sawequals)
1439             {
1440               /* Is it a quoted argument? */
1441               if(*ptr=='"')
1442                 {
1443                   ptr++;
1444                   end=strchr(ptr,'"');
1445                   if(end)
1446                     end++;
1447                 }
1448               else
1449                 end=strpbrk(ptr," ,");
1450             }
1451
1452           if(end && *end)
1453             {
1454               *end='\0';
1455               *stringp=end+1;
1456             }
1457           else
1458             *stringp=NULL;
1459         }
1460       else
1461         *stringp=NULL;
1462     }
1463
1464   return tok;
1465 }
1466
1467 /* Breaks an option value into key and value.  Returns NULL if there
1468    is no value.  Note that "string" is modified to remove the =value
1469    part. */
1470 char *
1471 argsplit(char *string)
1472 {
1473   char *equals,*arg=NULL;
1474
1475   equals=strchr(string,'=');
1476   if(equals)
1477     {
1478       char *quote,*space;
1479
1480       *equals='\0';
1481       arg=equals+1;
1482
1483       /* Quoted arg? */
1484       quote=strchr(arg,'"');
1485       if(quote)
1486         {
1487           arg=quote+1;
1488
1489           quote=strchr(arg,'"');
1490           if(quote)
1491             *quote='\0';
1492         }
1493       else
1494         {
1495           size_t spaces;
1496
1497           /* Trim leading spaces off of the arg */
1498           spaces=strspn(arg," ");
1499           arg+=spaces;
1500         }
1501
1502       /* Trim tailing spaces off of the tag */
1503       space=strchr(string,' ');
1504       if(space)
1505         *space='\0';
1506     }
1507
1508   return arg;
1509 }
1510
1511 /* Return the length of the initial token, leaving off any
1512    argument. */
1513 static size_t
1514 optlen(const char *s)
1515 {
1516   char *end=strpbrk(s," =");
1517
1518   if(end)
1519     return end-s;
1520   else
1521     return strlen(s);
1522 }
1523
1524
1525 /* Note: This function returns true on success.  */
1526 int
1527 parse_options(char *str,unsigned int *options,
1528               struct parse_options *opts,int noisy)
1529 {
1530   char *tok;
1531
1532   if (str && !strcmp (str, "help"))
1533     {
1534       int i,maxlen=0;
1535
1536       /* Figure out the longest option name so we can line these up
1537          neatly. */
1538       for(i=0;opts[i].name;i++)
1539         if(opts[i].help && maxlen<strlen(opts[i].name))
1540           maxlen=strlen(opts[i].name);
1541
1542       for(i=0;opts[i].name;i++)
1543         if(opts[i].help)
1544           es_printf("%s%*s%s\n",opts[i].name,
1545                     maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1546
1547       g10_exit(0);
1548     }
1549
1550   while((tok=optsep(&str)))
1551     {
1552       int i,rev=0;
1553       char *otok=tok;
1554
1555       if(tok[0]=='\0')
1556         continue;
1557
1558       if(ascii_strncasecmp("no-",tok,3)==0)
1559         {
1560           rev=1;
1561           tok+=3;
1562         }
1563
1564       for(i=0;opts[i].name;i++)
1565         {
1566           size_t toklen=optlen(tok);
1567
1568           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1569             {
1570               /* We have a match, but it might be incomplete */
1571               if(toklen!=strlen(opts[i].name))
1572                 {
1573                   int j;
1574
1575                   for(j=i+1;opts[j].name;j++)
1576                     {
1577                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1578                         {
1579                           if(noisy)
1580                             log_info(_("ambiguous option '%s'\n"),otok);
1581                           return 0;
1582                         }
1583                     }
1584                 }
1585
1586               if(rev)
1587                 {
1588                   *options&=~opts[i].bit;
1589                   if(opts[i].value)
1590                     *opts[i].value=NULL;
1591                 }
1592               else
1593                 {
1594                   *options|=opts[i].bit;
1595                   if(opts[i].value)
1596                     *opts[i].value=argsplit(tok);
1597                 }
1598               break;
1599             }
1600         }
1601
1602       if(!opts[i].name)
1603         {
1604           if(noisy)
1605             log_info(_("unknown option '%s'\n"),otok);
1606           return 0;
1607         }
1608     }
1609
1610   return 1;
1611 }
1612
1613
1614 /* Similar to access(2), but uses PATH to find the file. */
1615 int
1616 path_access(const char *file,int mode)
1617 {
1618   char *envpath;
1619   int ret=-1;
1620
1621   envpath=getenv("PATH");
1622
1623   if(!envpath
1624 #ifdef HAVE_DRIVE_LETTERS
1625      || (((file[0]>='A' && file[0]<='Z')
1626           || (file[0]>='a' && file[0]<='z'))
1627          && file[1]==':')
1628 #else
1629      || file[0]=='/'
1630 #endif
1631      )
1632     return access(file,mode);
1633   else
1634     {
1635       /* At least as large as, but most often larger than we need. */
1636       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1637       char *split,*item,*path=xstrdup(envpath);
1638
1639       split=path;
1640
1641       while((item=strsep(&split,PATHSEP_S)))
1642         {
1643           strcpy(buffer,item);
1644           strcat(buffer,"/");
1645           strcat(buffer,file);
1646           ret=access(buffer,mode);
1647           if(ret==0)
1648             break;
1649         }
1650
1651       xfree(path);
1652       xfree(buffer);
1653     }
1654
1655   return ret;
1656 }
1657
1658
1659 \f
1660 /* Return the number of public key parameters as used by OpenPGP.  */
1661 int
1662 pubkey_get_npkey (pubkey_algo_t algo)
1663 {
1664   switch (algo)
1665     {
1666     case PUBKEY_ALGO_RSA:
1667     case PUBKEY_ALGO_RSA_E:
1668     case PUBKEY_ALGO_RSA_S:     return 2;
1669     case PUBKEY_ALGO_ELGAMAL_E: return 3;
1670     case PUBKEY_ALGO_DSA:       return 4;
1671     case PUBKEY_ALGO_ECDH:      return 3;
1672     case PUBKEY_ALGO_ECDSA:     return 2;
1673     case PUBKEY_ALGO_ELGAMAL:   return 3;
1674     case PUBKEY_ALGO_EDDSA:     return 2;
1675     default: return 0;
1676     }
1677 }
1678
1679
1680 /* Return the number of secret key parameters as used by OpenPGP.  */
1681 int
1682 pubkey_get_nskey (pubkey_algo_t algo)
1683 {
1684   switch (algo)
1685     {
1686     case PUBKEY_ALGO_RSA:
1687     case PUBKEY_ALGO_RSA_E:
1688     case PUBKEY_ALGO_RSA_S:     return 6;
1689     case PUBKEY_ALGO_ELGAMAL_E: return 4;
1690     case PUBKEY_ALGO_DSA:       return 5;
1691     case PUBKEY_ALGO_ECDH:      return 4;
1692     case PUBKEY_ALGO_ECDSA:     return 3;
1693     case PUBKEY_ALGO_ELGAMAL:   return 4;
1694     case PUBKEY_ALGO_EDDSA:     return 3;
1695     default: return 0;
1696     }
1697 }
1698
1699 /* Temporary helper. */
1700 int
1701 pubkey_get_nsig (pubkey_algo_t algo)
1702 {
1703   switch (algo)
1704     {
1705     case PUBKEY_ALGO_RSA:
1706     case PUBKEY_ALGO_RSA_E:
1707     case PUBKEY_ALGO_RSA_S:     return 1;
1708     case PUBKEY_ALGO_ELGAMAL_E: return 0;
1709     case PUBKEY_ALGO_DSA:       return 2;
1710     case PUBKEY_ALGO_ECDH:      return 0;
1711     case PUBKEY_ALGO_ECDSA:     return 2;
1712     case PUBKEY_ALGO_ELGAMAL:   return 2;
1713     case PUBKEY_ALGO_EDDSA:     return 2;
1714     default: return 0;
1715     }
1716 }
1717
1718
1719 /* Temporary helper. */
1720 int
1721 pubkey_get_nenc (pubkey_algo_t algo)
1722 {
1723   switch (algo)
1724     {
1725     case PUBKEY_ALGO_RSA:
1726     case PUBKEY_ALGO_RSA_E:
1727     case PUBKEY_ALGO_RSA_S:     return 1;
1728     case PUBKEY_ALGO_ELGAMAL_E: return 2;
1729     case PUBKEY_ALGO_DSA:       return 0;
1730     case PUBKEY_ALGO_ECDH:      return 2;
1731     case PUBKEY_ALGO_ECDSA:     return 0;
1732     case PUBKEY_ALGO_ELGAMAL:   return 2;
1733     case PUBKEY_ALGO_EDDSA:     return 0;
1734     default: return 0;
1735     }
1736 }
1737
1738
1739 /* Temporary helper. */
1740 unsigned int
1741 pubkey_nbits( int algo, gcry_mpi_t *key )
1742 {
1743   int rc, nbits;
1744   gcry_sexp_t sexp;
1745
1746   if (algo == PUBKEY_ALGO_DSA
1747       && key[0] && key[1] && key[2] && key[3])
1748     {
1749       rc = gcry_sexp_build (&sexp, NULL,
1750                             "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1751                             key[0], key[1], key[2], key[3] );
1752     }
1753   else if ((algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E)
1754            && key[0] && key[1] && key[2])
1755     {
1756       rc = gcry_sexp_build (&sexp, NULL,
1757                             "(public-key(elg(p%m)(g%m)(y%m)))",
1758                             key[0], key[1], key[2] );
1759     }
1760   else if (is_RSA (algo)
1761            && key[0] && key[1])
1762     {
1763       rc = gcry_sexp_build (&sexp, NULL,
1764                             "(public-key(rsa(n%m)(e%m)))",
1765                             key[0], key[1] );
1766     }
1767   else if ((algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_ECDH
1768             || algo == PUBKEY_ALGO_EDDSA)
1769            && key[0] && key[1])
1770     {
1771       char *curve = openpgp_oid_to_str (key[0]);
1772       if (!curve)
1773         rc = gpg_error_from_syserror ();
1774       else
1775         {
1776           rc = gcry_sexp_build (&sexp, NULL,
1777                                 "(public-key(ecc(curve%s)(q%m)))",
1778                                 curve, key[1]);
1779           xfree (curve);
1780         }
1781     }
1782   else
1783     return 0;
1784
1785   if (rc)
1786     BUG ();
1787
1788   nbits = gcry_pk_get_nbits (sexp);
1789   gcry_sexp_release (sexp);
1790   return nbits;
1791 }
1792
1793
1794
1795 int
1796 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1797 {
1798   int n = 0;
1799   size_t nwritten;
1800
1801   if (!a)
1802     return es_fprintf (fp, "[MPI_NULL]");
1803   if (!mode)
1804     {
1805       unsigned int n1;
1806       n1 = gcry_mpi_get_nbits(a);
1807       n += es_fprintf (fp, "[%u bits]", n1);
1808     }
1809   else if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
1810     {
1811       unsigned int nbits;
1812       unsigned char *p = gcry_mpi_get_opaque (a, &nbits);
1813       if (!p)
1814         n += es_fprintf (fp, "[invalid opaque value]");
1815       else
1816         {
1817           if (!es_write_hexstring (fp, p, (nbits + 7)/8, 0, &nwritten))
1818             n += nwritten;
1819         }
1820     }
1821   else
1822     {
1823       unsigned char *buffer;
1824       size_t buflen;
1825
1826       if (gcry_mpi_aprint (GCRYMPI_FMT_USG, &buffer, &buflen, a))
1827         BUG ();
1828       if (!es_write_hexstring (fp, buffer, buflen, 0, &nwritten))
1829         n += nwritten;
1830       gcry_free (buffer);
1831     }
1832   return n;
1833 }
1834
1835
1836 /* pkey[1] or skey[1] is Q for ECDSA, which is an uncompressed point,
1837    i.e.  04 <x> <y> */
1838 unsigned int
1839 ecdsa_qbits_from_Q (unsigned int qbits)
1840 {
1841   if ((qbits%8) > 3)
1842     {
1843       log_error (_("ECDSA public key is expected to be in SEC encoding "
1844                    "multiple of 8 bits\n"));
1845       return 0;
1846     }
1847   qbits -= qbits%8;
1848   qbits /= 2;
1849   return qbits;
1850 }
1851
1852
1853 /* Ignore signatures and certifications made over certain digest
1854  * algorithms by default, MD5 is considered weak.  This allows users
1855  * to deprecate support for other algorithms as well.
1856  */
1857 void
1858 additional_weak_digest (const char* digestname)
1859 {
1860   struct weakhash *weak = NULL;
1861   const enum gcry_md_algos algo = string_to_digest_algo(digestname);
1862
1863   if (algo == GCRY_MD_NONE)
1864     {
1865       log_error (_("unknown weak digest '%s'\n"), digestname);
1866       return;
1867     }
1868
1869   /* Check to ensure it's not already present.  */
1870   for (weak = opt.weak_digests; weak; weak = weak->next)
1871     if (algo == weak->algo)
1872       return;
1873
1874   /* Add it to the head of the list.  */
1875   weak = xmalloc(sizeof(*weak));
1876   weak->algo = algo;
1877   weak->rejection_shown = 0;
1878   weak->next = opt.weak_digests;
1879   opt.weak_digests = weak;
1880 }