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