gpg: Ensure all weak digest rejection notices are shown
[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 <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <errno.h>
28 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
29 #include <asm/sysinfo.h>
30 #include <asm/unistd.h>
31 #endif
32 #ifdef HAVE_SETRLIMIT
33 #include <time.h>
34 #include <sys/time.h>
35 #include <sys/resource.h>
36 #endif
37 #ifdef ENABLE_SELINUX_HACKS
38 #include <sys/stat.h>
39 #endif
40
41 #ifdef HAVE_W32_SYSTEM
42 #include <time.h>
43 #include <process.h>
44 #ifdef HAVE_WINSOCK2_H
45 # include <winsock2.h>
46 #endif
47 #include <windows.h>
48 #include <shlobj.h>
49 #ifndef CSIDL_APPDATA
50 #define CSIDL_APPDATA 0x001a
51 #endif
52 #ifndef CSIDL_LOCAL_APPDATA
53 #define CSIDL_LOCAL_APPDATA 0x001c
54 #endif
55 #ifndef CSIDL_FLAG_CREATE
56 #define CSIDL_FLAG_CREATE 0x8000
57 #endif
58 #endif /*HAVE_W32_SYSTEM*/
59
60 #include "gpg.h"
61 #ifdef HAVE_W32_SYSTEM
62 # include "status.h"
63 #endif /*HAVE_W32_SYSTEM*/
64 #include "util.h"
65 #include "main.h"
66 #include "photoid.h"
67 #include "options.h"
68 #include "call-agent.h"
69 #include "i18n.h"
70
71 #include <assert.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 immediatley 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 /* Map OpenPGP algo numbers to those used by Libgcrypt.  We need to do
361    this for algorithms we implemented in Libgcrypt after they become
362    part of OpenPGP.  */
363 enum gcry_cipher_algos
364 map_cipher_openpgp_to_gcry (cipher_algo_t algo)
365 {
366   switch (algo)
367     {
368     case CIPHER_ALGO_NONE:        return GCRY_CIPHER_NONE;
369
370 #ifdef GPG_USE_IDEA
371     case CIPHER_ALGO_IDEA:        return GCRY_CIPHER_IDEA;
372 #else
373     case CIPHER_ALGO_IDEA:        return 0;
374 #endif
375
376     case CIPHER_ALGO_3DES:        return GCRY_CIPHER_3DES;
377
378 #ifdef GPG_USE_CAST5
379     case CIPHER_ALGO_CAST5:       return GCRY_CIPHER_CAST5;
380 #else
381     case CIPHER_ALGO_CAST5:       return 0;
382 #endif
383
384 #ifdef GPG_USE_BLOWFISH
385     case CIPHER_ALGO_BLOWFISH:    return GCRY_CIPHER_BLOWFISH;
386 #else
387     case CIPHER_ALGO_BLOWFISH:    return 0;
388 #endif
389
390 #ifdef GPG_USE_AES128
391     case CIPHER_ALGO_AES:         return GCRY_CIPHER_AES;
392 #else
393     case CIPHER_ALGO_AES:         return 0;
394 #endif
395
396 #ifdef GPG_USE_AES192
397     case CIPHER_ALGO_AES192:      return GCRY_CIPHER_AES192;
398 #else
399     case CIPHER_ALGO_AES192:      return 0;
400 #endif
401
402 #ifdef GPG_USE_AES256
403     case CIPHER_ALGO_AES256:      return GCRY_CIPHER_AES256;
404 #else
405     case CIPHER_ALGO_AES256:      return 0;
406 #endif
407
408 #ifdef GPG_USE_TWOFISH
409     case CIPHER_ALGO_TWOFISH:     return GCRY_CIPHER_TWOFISH;
410 #else
411     case CIPHER_ALGO_TWOFISH:     return 0;
412 #endif
413
414 #ifdef GPG_USE_CAMELLIA128
415     case CIPHER_ALGO_CAMELLIA128: return GCRY_CIPHER_CAMELLIA128;
416 #else
417     case CIPHER_ALGO_CAMELLIA128: return 0;
418 #endif
419
420 #ifdef GPG_USE_CAMELLIA192
421     case CIPHER_ALGO_CAMELLIA192: return GCRY_CIPHER_CAMELLIA192;
422 #else
423     case CIPHER_ALGO_CAMELLIA192: return 0;
424 #endif
425
426 #ifdef GPG_USE_CAMELLIA256
427     case CIPHER_ALGO_CAMELLIA256: return GCRY_CIPHER_CAMELLIA256;
428 #else
429     case CIPHER_ALGO_CAMELLIA256: return 0;
430 #endif
431     }
432   return 0;
433 }
434
435 /* The inverse function of above.  */
436 static cipher_algo_t
437 map_cipher_gcry_to_openpgp (enum gcry_cipher_algos algo)
438 {
439   switch (algo)
440     {
441     case GCRY_CIPHER_NONE:        return CIPHER_ALGO_NONE;
442     case GCRY_CIPHER_IDEA:        return CIPHER_ALGO_IDEA;
443     case GCRY_CIPHER_3DES:        return CIPHER_ALGO_3DES;
444     case GCRY_CIPHER_CAST5:       return CIPHER_ALGO_CAST5;
445     case GCRY_CIPHER_BLOWFISH:    return CIPHER_ALGO_BLOWFISH;
446     case GCRY_CIPHER_AES:         return CIPHER_ALGO_AES;
447     case GCRY_CIPHER_AES192:      return CIPHER_ALGO_AES192;
448     case GCRY_CIPHER_AES256:      return CIPHER_ALGO_AES256;
449     case GCRY_CIPHER_TWOFISH:     return CIPHER_ALGO_TWOFISH;
450     case GCRY_CIPHER_CAMELLIA128: return CIPHER_ALGO_CAMELLIA128;
451     case GCRY_CIPHER_CAMELLIA192: return CIPHER_ALGO_CAMELLIA192;
452     case GCRY_CIPHER_CAMELLIA256: return CIPHER_ALGO_CAMELLIA256;
453     default: return 0;
454     }
455 }
456
457 /* Map Gcrypt public key algorithm numbers to those used by OpenPGP.
458    FIXME: This mapping is used at only two places - we should get rid
459    of it.  */
460 pubkey_algo_t
461 map_pk_gcry_to_openpgp (enum gcry_pk_algos algo)
462 {
463   switch (algo)
464     {
465     case GCRY_PK_ECDSA:  return PUBKEY_ALGO_ECDSA;
466     case GCRY_PK_ECDH:   return PUBKEY_ALGO_ECDH;
467     default: return algo < 110 ? algo : 0;
468     }
469 }
470
471
472 /* Return the block length of an OpenPGP cipher algorithm.  */
473 int
474 openpgp_cipher_blocklen (cipher_algo_t algo)
475 {
476   /* We use the numbers from OpenPGP to be sure that we get the right
477      block length.  This is so that the packet parsing code works even
478      for unknown algorithms (for which we assume 8 due to tradition).
479
480      NOTE: If you change the the returned blocklen above 16, check
481      the callers because they may use a fixed size buffer of that
482      size. */
483   switch (algo)
484     {
485     case CIPHER_ALGO_AES:
486     case CIPHER_ALGO_AES192:
487     case CIPHER_ALGO_AES256:
488     case CIPHER_ALGO_TWOFISH:
489     case CIPHER_ALGO_CAMELLIA128:
490     case CIPHER_ALGO_CAMELLIA192:
491     case CIPHER_ALGO_CAMELLIA256:
492       return 16;
493
494     default:
495       return 8;
496     }
497 }
498
499 /****************
500  * Wrapper around the libgcrypt function with additonal checks on
501  * the OpenPGP contraints for the algo ID.
502  */
503 int
504 openpgp_cipher_test_algo (cipher_algo_t algo)
505 {
506   enum gcry_cipher_algos ga;
507
508   ga = map_cipher_openpgp_to_gcry (algo);
509   if (!ga)
510     return gpg_error (GPG_ERR_CIPHER_ALGO);
511
512   return gcry_cipher_test_algo (ga);
513 }
514
515 /* Map the OpenPGP cipher algorithm whose ID is contained in ALGORITHM to a
516    string representation of the algorithm name.  For unknown algorithm
517    IDs this function returns "?".  */
518 const char *
519 openpgp_cipher_algo_name (cipher_algo_t algo)
520 {
521   switch (algo)
522     {
523     case CIPHER_ALGO_NONE:        break;
524     case CIPHER_ALGO_IDEA:        return "IDEA";
525     case CIPHER_ALGO_3DES:        return "3DES";
526     case CIPHER_ALGO_CAST5:       return "CAST5";
527     case CIPHER_ALGO_BLOWFISH:    return "BLOWFISH";
528     case CIPHER_ALGO_AES:         return "AES";
529     case CIPHER_ALGO_AES192:      return "AES192";
530     case CIPHER_ALGO_AES256:      return "AES256";
531     case CIPHER_ALGO_TWOFISH:     return "TWOFISH";
532     case CIPHER_ALGO_CAMELLIA128: return "CAMELLIA128";
533     case CIPHER_ALGO_CAMELLIA192: return "CAMELLIA192";
534     case CIPHER_ALGO_CAMELLIA256: return "CAMELLIA256";
535     }
536   return "?";
537 }
538
539
540 /* Return 0 if ALGO is a supported OpenPGP public key algorithm.  */
541 int
542 openpgp_pk_test_algo (pubkey_algo_t algo)
543 {
544   return openpgp_pk_test_algo2 (algo, 0);
545 }
546
547
548 /* Return 0 if ALGO is a supported OpenPGP public key algorithm and
549    allows the usage USE.  */
550 int
551 openpgp_pk_test_algo2 (pubkey_algo_t algo, unsigned int use)
552 {
553   enum gcry_pk_algos ga = 0;
554   size_t use_buf = use;
555
556   switch (algo)
557     {
558 #ifdef GPG_USE_RSA
559     case PUBKEY_ALGO_RSA:       ga = GCRY_PK_RSA;   break;
560     case PUBKEY_ALGO_RSA_E:     ga = GCRY_PK_RSA_E; break;
561     case PUBKEY_ALGO_RSA_S:     ga = GCRY_PK_RSA_S; break;
562 #else
563     case PUBKEY_ALGO_RSA:       break;
564     case PUBKEY_ALGO_RSA_E:     break;
565     case PUBKEY_ALGO_RSA_S:     break;
566 #endif
567
568     case PUBKEY_ALGO_ELGAMAL_E: ga = GCRY_PK_ELG;   break;
569     case PUBKEY_ALGO_DSA:       ga = GCRY_PK_DSA;   break;
570
571 #ifdef GPG_USE_ECDH
572     case PUBKEY_ALGO_ECDH:      ga = GCRY_PK_ECC;   break;
573 #else
574     case PUBKEY_ALGO_ECDH:      break;
575 #endif
576
577 #ifdef GPG_USE_ECDSA
578     case PUBKEY_ALGO_ECDSA:     ga = GCRY_PK_ECC;   break;
579 #else
580     case PUBKEY_ALGO_ECDSA:     break;
581 #endif
582
583 #ifdef GPG_USE_EDDSA
584     case PUBKEY_ALGO_EDDSA:     ga = GCRY_PK_ECC;   break;
585 #else
586     case PUBKEY_ALGO_EDDSA:     break;
587 #endif
588
589     case PUBKEY_ALGO_ELGAMAL:
590       /* Dont't allow type 20 keys unless in rfc2440 mode.  */
591       if (RFC2440)
592         ga = GCRY_PK_ELG;
593       break;
594     }
595   if (!ga)
596     return gpg_error (GPG_ERR_PUBKEY_ALGO);
597
598   /* No check whether Libgcrypt has support for the algorithm.  */
599   return gcry_pk_algo_info (ga, GCRYCTL_TEST_ALGO, NULL, &use_buf);
600 }
601
602
603 int
604 openpgp_pk_algo_usage ( int algo )
605 {
606     int use = 0;
607
608     /* They are hardwired in gpg 1.0. */
609     switch ( algo ) {
610       case PUBKEY_ALGO_RSA:
611           use = (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG
612                  | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH);
613           break;
614       case PUBKEY_ALGO_RSA_E:
615       case PUBKEY_ALGO_ECDH:
616           use = PUBKEY_USAGE_ENC;
617           break;
618       case PUBKEY_ALGO_RSA_S:
619           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG;
620           break;
621       case PUBKEY_ALGO_ELGAMAL:
622           if (RFC2440)
623              use = PUBKEY_USAGE_ENC;
624           break;
625       case PUBKEY_ALGO_ELGAMAL_E:
626           use = PUBKEY_USAGE_ENC;
627           break;
628       case PUBKEY_ALGO_DSA:
629           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
630           break;
631       case PUBKEY_ALGO_ECDSA:
632       case PUBKEY_ALGO_EDDSA:
633           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
634       default:
635           break;
636     }
637     return use;
638 }
639
640 /* Map the OpenPGP pubkey algorithm whose ID is contained in ALGO to a
641    string representation of the algorithm name.  For unknown algorithm
642    IDs this function returns "?".  */
643 const char *
644 openpgp_pk_algo_name (pubkey_algo_t algo)
645 {
646   switch (algo)
647     {
648     case PUBKEY_ALGO_RSA:
649     case PUBKEY_ALGO_RSA_E:
650     case PUBKEY_ALGO_RSA_S:     return "RSA";
651     case PUBKEY_ALGO_ELGAMAL:
652     case PUBKEY_ALGO_ELGAMAL_E: return "ELG";
653     case PUBKEY_ALGO_DSA:       return "DSA";
654     case PUBKEY_ALGO_ECDH:      return "ECDH";
655     case PUBKEY_ALGO_ECDSA:     return "ECDSA";
656     case PUBKEY_ALGO_EDDSA:     return "EDDSA";
657     }
658   return "?";
659 }
660
661
662 /* Explicit mapping of OpenPGP digest algos to Libgcrypt.  */
663 /* FIXME: We do not yes use it everywhere.  */
664 enum gcry_md_algos
665 map_md_openpgp_to_gcry (digest_algo_t algo)
666 {
667   switch (algo)
668     {
669 #ifdef GPG_USE_MD5
670     case DIGEST_ALGO_MD5:    return GCRY_MD_MD5;
671 #else
672     case DIGEST_ALGO_MD5:    return 0;
673 #endif
674
675     case DIGEST_ALGO_SHA1:   return GCRY_MD_SHA1;
676
677 #ifdef GPG_USE_RMD160
678     case DIGEST_ALGO_RMD160: return GCRY_MD_RMD160;
679 #else
680     case DIGEST_ALGO_RMD160: return 0;
681 #endif
682
683 #ifdef GPG_USE_SHA224
684     case DIGEST_ALGO_SHA224: return GCRY_MD_SHA224;
685 #else
686     case DIGEST_ALGO_SHA224: return 0;
687 #endif
688
689     case DIGEST_ALGO_SHA256: return GCRY_MD_SHA256;
690
691 #ifdef GPG_USE_SHA384
692     case DIGEST_ALGO_SHA384: return GCRY_MD_SHA384;
693 #else
694     case DIGEST_ALGO_SHA384: return 0;
695 #endif
696
697 #ifdef GPG_USE_SHA512
698     case DIGEST_ALGO_SHA512: return GCRY_MD_SHA512;
699 #else
700     case DIGEST_ALGO_SHA512: return 0;
701 #endif
702     }
703   return 0;
704 }
705
706
707 /* Return 0 if ALGO is suitable and implemented OpenPGP hash
708    algorithm.  */
709 int
710 openpgp_md_test_algo (digest_algo_t algo)
711 {
712   enum gcry_md_algos ga;
713
714   ga = map_md_openpgp_to_gcry (algo);
715   if (!ga)
716     return gpg_error (GPG_ERR_DIGEST_ALGO);
717
718   return gcry_md_test_algo (ga);
719 }
720
721
722 /* Map the OpenPGP digest algorithm whose ID is contained in ALGO to a
723    string representation of the algorithm name.  For unknown algorithm
724    IDs this function returns "?".  */
725 const char *
726 openpgp_md_algo_name (int algo)
727 {
728   switch (algo)
729     {
730     case DIGEST_ALGO_MD5:    return "MD5";
731     case DIGEST_ALGO_SHA1:   return "SHA1";
732     case DIGEST_ALGO_RMD160: return "RIPEMD160";
733     case DIGEST_ALGO_SHA256: return "SHA256";
734     case DIGEST_ALGO_SHA384: return "SHA384";
735     case DIGEST_ALGO_SHA512: return "SHA512";
736     case DIGEST_ALGO_SHA224: return "SHA224";
737     }
738   return "?";
739 }
740
741
742 static unsigned long
743 get_signature_count (PKT_public_key *pk)
744 {
745 #ifdef ENABLE_CARD_SUPPORT
746   struct agent_card_info_s info;
747
748   (void)pk;
749   if (!agent_scd_getattr ("SIG-COUNTER",&info))
750     return info.sig_counter;
751   else
752     return 0;
753 #else
754   (void)pk;
755   return 0;
756 #endif
757 }
758
759 /* Expand %-strings.  Returns a string which must be xfreed.  Returns
760    NULL if the string cannot be expanded (too large). */
761 char *
762 pct_expando(const char *string,struct expando_args *args)
763 {
764   const char *ch=string;
765   int idx=0,maxlen=0,done=0;
766   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
767   char *ret=NULL;
768
769   if(args->pk)
770     keyid_from_pk(args->pk,pk_keyid);
771
772   if(args->pksk)
773     keyid_from_pk (args->pksk, sk_keyid);
774
775   /* This is used so that %k works in photoid command strings in
776      --list-secret-keys (which of course has a sk, but no pk). */
777   if(!args->pk && args->pksk)
778     keyid_from_pk (args->pksk, pk_keyid);
779
780   while(*ch!='\0')
781     {
782       if(!done)
783         {
784           /* 8192 is way bigger than we'll need here */
785           if(maxlen>=8192)
786             goto fail;
787
788           maxlen+=1024;
789           ret=xrealloc(ret,maxlen);
790         }
791
792       done=0;
793
794       if(*ch=='%')
795         {
796           switch(*(ch+1))
797             {
798             case 's': /* short key id */
799               if(idx+8<maxlen)
800                 {
801                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
802                   idx+=8;
803                   done=1;
804                 }
805               break;
806
807             case 'S': /* long key id */
808               if(idx+16<maxlen)
809                 {
810                   sprintf(&ret[idx],"%08lX%08lX",
811                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
812                   idx+=16;
813                   done=1;
814                 }
815               break;
816
817             case 'k': /* short key id */
818               if(idx+8<maxlen)
819                 {
820                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
821                   idx+=8;
822                   done=1;
823                 }
824               break;
825
826             case 'K': /* long key id */
827               if(idx+16<maxlen)
828                 {
829                   sprintf(&ret[idx],"%08lX%08lX",
830                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
831                   idx+=16;
832                   done=1;
833                 }
834               break;
835
836             case 'U': /* z-base-32 encoded user id hash. */
837               if (args->namehash)
838                 {
839                   char *tmp = zb32_encode (args->namehash, 8*20);
840                   if (tmp)
841                     {
842                       if (idx + strlen (tmp) < maxlen)
843                         {
844                           strcpy (ret+idx, tmp);
845                           idx += strlen (tmp);
846                         }
847                       xfree (tmp);
848                       done = 1;
849                     }
850                 }
851               break;
852
853             case 'c': /* signature count from card, if any. */
854               if(idx+10<maxlen)
855                 {
856                   sprintf (&ret[idx],"%lu", get_signature_count (args->pksk));
857                   idx+=strlen(&ret[idx]);
858                   done=1;
859                 }
860               break;
861
862             case 'f': /* Fingerprint of key being signed */
863             case 'p': /* Fingerprint of the primary key making the signature. */
864             case 'g': /* Fingerprint of thge key making the signature.  */
865               {
866                 byte array[MAX_FINGERPRINT_LEN];
867                 size_t len;
868                 int i;
869
870                 if ((*(ch+1))=='f' && args->pk)
871                   fingerprint_from_pk (args->pk, array, &len);
872                 else if ((*(ch+1))=='p' && args->pksk)
873                   {
874                     if(args->pksk->flags.primary)
875                       fingerprint_from_pk (args->pksk, array, &len);
876                     else if (args->pksk->main_keyid[0]
877                              || args->pksk->main_keyid[1])
878                       {
879                         /* Not the primary key: Find the fingerprint
880                            of the primary key.  */
881                         PKT_public_key *pk=
882                           xmalloc_clear(sizeof(PKT_public_key));
883
884                         if (!get_pubkey_fast (pk,args->pksk->main_keyid))
885                           fingerprint_from_pk (pk, array, &len);
886                         else
887                           memset (array, 0, (len=MAX_FINGERPRINT_LEN));
888                         free_public_key (pk);
889                       }
890                     else /* Oops: info about the primary key missing.  */
891                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
892                   }
893                 else if((*(ch+1))=='g' && args->pksk)
894                   fingerprint_from_pk (args->pksk, array, &len);
895                 else
896                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
897
898                 if(idx+(len*2)<maxlen)
899                   {
900                     for(i=0;i<len;i++)
901                       {
902                         sprintf(&ret[idx],"%02X",array[i]);
903                         idx+=2;
904                       }
905                     done=1;
906                   }
907               }
908               break;
909
910             case 'v': /* validity letters */
911               if(args->validity_info && idx+1<maxlen)
912                 {
913                   ret[idx++]=args->validity_info;
914                   ret[idx]='\0';
915                   done=1;
916                 }
917               break;
918
919               /* The text string types */
920             case 't':
921             case 'T':
922             case 'V':
923               {
924                 const char *str=NULL;
925
926                 switch(*(ch+1))
927                   {
928                   case 't': /* e.g. "jpg" */
929                     str=image_type_to_string(args->imagetype,0);
930                     break;
931
932                   case 'T': /* e.g. "image/jpeg" */
933                     str=image_type_to_string(args->imagetype,2);
934                     break;
935
936                   case 'V': /* e.g. "full", "expired", etc. */
937                     str=args->validity_string;
938                     break;
939                   }
940
941                 if(str && idx+strlen(str)<maxlen)
942                   {
943                     strcpy(&ret[idx],str);
944                     idx+=strlen(str);
945                     done=1;
946                   }
947               }
948               break;
949
950             case '%':
951               if(idx+1<maxlen)
952                 {
953                   ret[idx++]='%';
954                   ret[idx]='\0';
955                   done=1;
956                 }
957               break;
958
959               /* Any unknown %-keys (like %i, %o, %I, and %O) are
960                  passed through for later expansion.  Note this also
961                  handles the case where the last character in the
962                  string is a '%' - the terminating \0 will end up here
963                  and properly terminate the string. */
964             default:
965               if(idx+2<maxlen)
966                 {
967                   ret[idx++]='%';
968                   ret[idx++]=*(ch+1);
969                   ret[idx]='\0';
970                   done=1;
971                 }
972               break;
973               }
974
975           if(done)
976             ch++;
977         }
978       else
979         {
980           if(idx+1<maxlen)
981             {
982               ret[idx++]=*ch;
983               ret[idx]='\0';
984               done=1;
985             }
986         }
987
988       if(done)
989         ch++;
990     }
991
992   return ret;
993
994  fail:
995   xfree(ret);
996   return NULL;
997 }
998
999 void
1000 deprecated_warning(const char *configname,unsigned int configlineno,
1001                    const char *option,const char *repl1,const char *repl2)
1002 {
1003   if(configname)
1004     {
1005       if(strncmp("--",option,2)==0)
1006         option+=2;
1007
1008       if(strncmp("--",repl1,2)==0)
1009         repl1+=2;
1010
1011       log_info(_("%s:%d: deprecated option \"%s\"\n"),
1012                configname,configlineno,option);
1013     }
1014   else
1015     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
1016
1017   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
1018 }
1019
1020
1021 void
1022 deprecated_command (const char *name)
1023 {
1024   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
1025            name);
1026 }
1027
1028
1029 void
1030 obsolete_scdaemon_option (const char *configname, unsigned int configlineno,
1031                           const char *name)
1032 {
1033   if (configname)
1034     log_info (_("%s:%u: \"%s\" is obsolete in this file"
1035                 " - it only has effect in %s\n"),
1036               configname, configlineno, name, SCDAEMON_NAME EXTSEP_S "conf");
1037   else
1038     log_info (_("WARNING: \"%s%s\" is an obsolete option"
1039                 " - it has no effect except on %s\n"),
1040               "--", name, SCDAEMON_NAME);
1041 }
1042
1043
1044 /*
1045  * Wrapper around gcry_cipher_map_name to provide a fallback using the
1046  * "Sn" syntax as used by the preference strings.
1047  */
1048 int
1049 string_to_cipher_algo (const char *string)
1050 {
1051   int val;
1052
1053   val = map_cipher_gcry_to_openpgp (gcry_cipher_map_name (string));
1054   if (!val && string && (string[0]=='S' || string[0]=='s'))
1055     {
1056       char *endptr;
1057
1058       string++;
1059       val = strtol (string, &endptr, 10);
1060       if (!*string || *endptr || openpgp_cipher_test_algo (val))
1061         val = 0;
1062     }
1063
1064   return val;
1065 }
1066
1067 /*
1068  * Wrapper around gcry_md_map_name to provide a fallback using the
1069  * "Hn" syntax as used by the preference strings.
1070  */
1071 int
1072 string_to_digest_algo (const char *string)
1073 {
1074   int val;
1075
1076   /* FIXME: We should make use of our wrapper fucntion and not assume
1077      that there is a 1 to 1 mapping between OpenPGP and Libgcrypt.  */
1078   val = gcry_md_map_name (string);
1079   if (!val && string && (string[0]=='H' || string[0]=='h'))
1080     {
1081       char *endptr;
1082
1083       string++;
1084       val = strtol (string, &endptr, 10);
1085       if (!*string || *endptr || openpgp_md_test_algo (val))
1086         val = 0;
1087     }
1088
1089   return val;
1090 }
1091
1092
1093
1094 const char *
1095 compress_algo_to_string(int algo)
1096 {
1097   const char *s=NULL;
1098
1099   switch(algo)
1100     {
1101     case COMPRESS_ALGO_NONE:
1102       s=_("Uncompressed");
1103       break;
1104
1105     case COMPRESS_ALGO_ZIP:
1106       s="ZIP";
1107       break;
1108
1109     case COMPRESS_ALGO_ZLIB:
1110       s="ZLIB";
1111       break;
1112
1113 #ifdef HAVE_BZIP2
1114     case COMPRESS_ALGO_BZIP2:
1115       s="BZIP2";
1116       break;
1117 #endif
1118     }
1119
1120   return s;
1121 }
1122
1123 int
1124 string_to_compress_algo(const char *string)
1125 {
1126   /* TRANSLATORS: See doc/TRANSLATE about this string. */
1127   if(match_multistr(_("uncompressed|none"),string))
1128     return 0;
1129   else if(ascii_strcasecmp(string,"uncompressed")==0)
1130     return 0;
1131   else if(ascii_strcasecmp(string,"none")==0)
1132     return 0;
1133   else if(ascii_strcasecmp(string,"zip")==0)
1134     return 1;
1135   else if(ascii_strcasecmp(string,"zlib")==0)
1136     return 2;
1137 #ifdef HAVE_BZIP2
1138   else if(ascii_strcasecmp(string,"bzip2")==0)
1139     return 3;
1140 #endif
1141   else if(ascii_strcasecmp(string,"z0")==0)
1142     return 0;
1143   else if(ascii_strcasecmp(string,"z1")==0)
1144     return 1;
1145   else if(ascii_strcasecmp(string,"z2")==0)
1146     return 2;
1147 #ifdef HAVE_BZIP2
1148   else if(ascii_strcasecmp(string,"z3")==0)
1149     return 3;
1150 #endif
1151   else
1152     return -1;
1153 }
1154
1155 int
1156 check_compress_algo(int algo)
1157 {
1158   switch (algo)
1159     {
1160     case 0: return 0;
1161 #ifdef HAVE_ZIP
1162     case 1:
1163     case 2: return 0;
1164 #endif
1165 #ifdef HAVE_BZIP2
1166     case 3: return 0;
1167 #endif
1168     default: return GPG_ERR_COMPR_ALGO;
1169     }
1170 }
1171
1172 int
1173 default_cipher_algo(void)
1174 {
1175   if(opt.def_cipher_algo)
1176     return opt.def_cipher_algo;
1177   else if(opt.personal_cipher_prefs)
1178     return opt.personal_cipher_prefs[0].value;
1179   else
1180     return opt.s2k_cipher_algo;
1181 }
1182
1183 /* There is no default_digest_algo function, but see
1184    sign.c:hash_for() */
1185
1186 int
1187 default_compress_algo(void)
1188 {
1189   if(opt.compress_algo!=-1)
1190     return opt.compress_algo;
1191   else if(opt.personal_compress_prefs)
1192     return opt.personal_compress_prefs[0].value;
1193   else
1194     return DEFAULT_COMPRESS_ALGO;
1195 }
1196
1197 const char *
1198 compliance_option_string(void)
1199 {
1200   char *ver="???";
1201
1202   switch(opt.compliance)
1203     {
1204     case CO_GNUPG:   return "--gnupg";
1205     case CO_RFC4880: return "--openpgp";
1206     case CO_RFC2440: return "--rfc2440";
1207     case CO_PGP6:    return "--pgp6";
1208     case CO_PGP7:    return "--pgp7";
1209     case CO_PGP8:    return "--pgp8";
1210     }
1211
1212   return ver;
1213 }
1214
1215 void
1216 compliance_failure(void)
1217 {
1218   char *ver="???";
1219
1220   switch(opt.compliance)
1221     {
1222     case CO_GNUPG:
1223       ver="GnuPG";
1224       break;
1225
1226     case CO_RFC4880:
1227       ver="OpenPGP";
1228       break;
1229
1230     case CO_RFC2440:
1231       ver="OpenPGP (older)";
1232       break;
1233
1234     case CO_PGP6:
1235       ver="PGP 6.x";
1236       break;
1237
1238     case CO_PGP7:
1239       ver="PGP 7.x";
1240       break;
1241
1242     case CO_PGP8:
1243       ver="PGP 8.x";
1244       break;
1245     }
1246
1247   log_info(_("this message may not be usable by %s\n"),ver);
1248   opt.compliance=CO_GNUPG;
1249 }
1250
1251 /* Break a string into successive option pieces.  Accepts single word
1252    options and key=value argument options. */
1253 char *
1254 optsep(char **stringp)
1255 {
1256   char *tok,*end;
1257
1258   tok=*stringp;
1259   if(tok)
1260     {
1261       end=strpbrk(tok," ,=");
1262       if(end)
1263         {
1264           int sawequals=0;
1265           char *ptr=end;
1266
1267           /* what we need to do now is scan along starting with *end,
1268              If the next character we see (ignoring spaces) is an =
1269              sign, then there is an argument. */
1270
1271           while(*ptr)
1272             {
1273               if(*ptr=='=')
1274                 sawequals=1;
1275               else if(*ptr!=' ')
1276                 break;
1277               ptr++;
1278             }
1279
1280           /* There is an argument, so grab that too.  At this point,
1281              ptr points to the first character of the argument. */
1282           if(sawequals)
1283             {
1284               /* Is it a quoted argument? */
1285               if(*ptr=='"')
1286                 {
1287                   ptr++;
1288                   end=strchr(ptr,'"');
1289                   if(end)
1290                     end++;
1291                 }
1292               else
1293                 end=strpbrk(ptr," ,");
1294             }
1295
1296           if(end && *end)
1297             {
1298               *end='\0';
1299               *stringp=end+1;
1300             }
1301           else
1302             *stringp=NULL;
1303         }
1304       else
1305         *stringp=NULL;
1306     }
1307
1308   return tok;
1309 }
1310
1311 /* Breaks an option value into key and value.  Returns NULL if there
1312    is no value.  Note that "string" is modified to remove the =value
1313    part. */
1314 char *
1315 argsplit(char *string)
1316 {
1317   char *equals,*arg=NULL;
1318
1319   equals=strchr(string,'=');
1320   if(equals)
1321     {
1322       char *quote,*space;
1323
1324       *equals='\0';
1325       arg=equals+1;
1326
1327       /* Quoted arg? */
1328       quote=strchr(arg,'"');
1329       if(quote)
1330         {
1331           arg=quote+1;
1332
1333           quote=strchr(arg,'"');
1334           if(quote)
1335             *quote='\0';
1336         }
1337       else
1338         {
1339           size_t spaces;
1340
1341           /* Trim leading spaces off of the arg */
1342           spaces=strspn(arg," ");
1343           arg+=spaces;
1344         }
1345
1346       /* Trim tailing spaces off of the tag */
1347       space=strchr(string,' ');
1348       if(space)
1349         *space='\0';
1350     }
1351
1352   return arg;
1353 }
1354
1355 /* Return the length of the initial token, leaving off any
1356    argument. */
1357 static size_t
1358 optlen(const char *s)
1359 {
1360   char *end=strpbrk(s," =");
1361
1362   if(end)
1363     return end-s;
1364   else
1365     return strlen(s);
1366 }
1367
1368 int
1369 parse_options(char *str,unsigned int *options,
1370               struct parse_options *opts,int noisy)
1371 {
1372   char *tok;
1373
1374   if (str && !strcmp (str, "help"))
1375     {
1376       int i,maxlen=0;
1377
1378       /* Figure out the longest option name so we can line these up
1379          neatly. */
1380       for(i=0;opts[i].name;i++)
1381         if(opts[i].help && maxlen<strlen(opts[i].name))
1382           maxlen=strlen(opts[i].name);
1383
1384       for(i=0;opts[i].name;i++)
1385         if(opts[i].help)
1386           es_printf("%s%*s%s\n",opts[i].name,
1387                     maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1388
1389       g10_exit(0);
1390     }
1391
1392   while((tok=optsep(&str)))
1393     {
1394       int i,rev=0;
1395       char *otok=tok;
1396
1397       if(tok[0]=='\0')
1398         continue;
1399
1400       if(ascii_strncasecmp("no-",tok,3)==0)
1401         {
1402           rev=1;
1403           tok+=3;
1404         }
1405
1406       for(i=0;opts[i].name;i++)
1407         {
1408           size_t toklen=optlen(tok);
1409
1410           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1411             {
1412               /* We have a match, but it might be incomplete */
1413               if(toklen!=strlen(opts[i].name))
1414                 {
1415                   int j;
1416
1417                   for(j=i+1;opts[j].name;j++)
1418                     {
1419                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1420                         {
1421                           if(noisy)
1422                             log_info(_("ambiguous option '%s'\n"),otok);
1423                           return 0;
1424                         }
1425                     }
1426                 }
1427
1428               if(rev)
1429                 {
1430                   *options&=~opts[i].bit;
1431                   if(opts[i].value)
1432                     *opts[i].value=NULL;
1433                 }
1434               else
1435                 {
1436                   *options|=opts[i].bit;
1437                   if(opts[i].value)
1438                     *opts[i].value=argsplit(tok);
1439                 }
1440               break;
1441             }
1442         }
1443
1444       if(!opts[i].name)
1445         {
1446           if(noisy)
1447             log_info(_("unknown option '%s'\n"),otok);
1448           return 0;
1449         }
1450     }
1451
1452   return 1;
1453 }
1454
1455
1456 /* Similar to access(2), but uses PATH to find the file. */
1457 int
1458 path_access(const char *file,int mode)
1459 {
1460   char *envpath;
1461   int ret=-1;
1462
1463   envpath=getenv("PATH");
1464
1465   if(!envpath
1466 #ifdef HAVE_DRIVE_LETTERS
1467      || (((file[0]>='A' && file[0]<='Z')
1468           || (file[0]>='a' && file[0]<='z'))
1469          && file[1]==':')
1470 #else
1471      || file[0]=='/'
1472 #endif
1473      )
1474     return access(file,mode);
1475   else
1476     {
1477       /* At least as large as, but most often larger than we need. */
1478       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1479       char *split,*item,*path=xstrdup(envpath);
1480
1481       split=path;
1482
1483       while((item=strsep(&split,PATHSEP_S)))
1484         {
1485           strcpy(buffer,item);
1486           strcat(buffer,"/");
1487           strcat(buffer,file);
1488           ret=access(buffer,mode);
1489           if(ret==0)
1490             break;
1491         }
1492
1493       xfree(path);
1494       xfree(buffer);
1495     }
1496
1497   return ret;
1498 }
1499
1500
1501 \f
1502 /* Return the number of public key parameters as used by OpenPGP.  */
1503 int
1504 pubkey_get_npkey (pubkey_algo_t algo)
1505 {
1506   switch (algo)
1507     {
1508     case PUBKEY_ALGO_RSA:
1509     case PUBKEY_ALGO_RSA_E:
1510     case PUBKEY_ALGO_RSA_S:     return 2;
1511     case PUBKEY_ALGO_ELGAMAL_E: return 3;
1512     case PUBKEY_ALGO_DSA:       return 4;
1513     case PUBKEY_ALGO_ECDH:      return 3;
1514     case PUBKEY_ALGO_ECDSA:     return 2;
1515     case PUBKEY_ALGO_ELGAMAL:   return 3;
1516     case PUBKEY_ALGO_EDDSA:     return 2;
1517     }
1518   return 0;
1519 }
1520
1521
1522 /* Return the number of secret key parameters as used by OpenPGP.  */
1523 int
1524 pubkey_get_nskey (pubkey_algo_t algo)
1525 {
1526   switch (algo)
1527     {
1528     case PUBKEY_ALGO_RSA:
1529     case PUBKEY_ALGO_RSA_E:
1530     case PUBKEY_ALGO_RSA_S:     return 6;
1531     case PUBKEY_ALGO_ELGAMAL_E: return 4;
1532     case PUBKEY_ALGO_DSA:       return 5;
1533     case PUBKEY_ALGO_ECDH:      return 4;
1534     case PUBKEY_ALGO_ECDSA:     return 3;
1535     case PUBKEY_ALGO_ELGAMAL:   return 4;
1536     case PUBKEY_ALGO_EDDSA:     return 3;
1537     }
1538   return 0;
1539 }
1540
1541 /* Temporary helper. */
1542 int
1543 pubkey_get_nsig (pubkey_algo_t algo)
1544 {
1545   switch (algo)
1546     {
1547     case PUBKEY_ALGO_RSA:
1548     case PUBKEY_ALGO_RSA_E:
1549     case PUBKEY_ALGO_RSA_S:     return 1;
1550     case PUBKEY_ALGO_ELGAMAL_E: return 0;
1551     case PUBKEY_ALGO_DSA:       return 2;
1552     case PUBKEY_ALGO_ECDH:      return 0;
1553     case PUBKEY_ALGO_ECDSA:     return 2;
1554     case PUBKEY_ALGO_ELGAMAL:   return 2;
1555     case PUBKEY_ALGO_EDDSA:     return 2;
1556     }
1557   return 0;
1558 }
1559
1560
1561 /* Temporary helper. */
1562 int
1563 pubkey_get_nenc (pubkey_algo_t algo)
1564 {
1565   switch (algo)
1566     {
1567     case PUBKEY_ALGO_RSA:
1568     case PUBKEY_ALGO_RSA_E:
1569     case PUBKEY_ALGO_RSA_S:     return 1;
1570     case PUBKEY_ALGO_ELGAMAL_E: return 2;
1571     case PUBKEY_ALGO_DSA:       return 0;
1572     case PUBKEY_ALGO_ECDH:      return 2;
1573     case PUBKEY_ALGO_ECDSA:     return 0;
1574     case PUBKEY_ALGO_ELGAMAL:   return 2;
1575     case PUBKEY_ALGO_EDDSA:     return 0;
1576     }
1577   return 0;
1578 }
1579
1580
1581 /* Temporary helper. */
1582 unsigned int
1583 pubkey_nbits( int algo, gcry_mpi_t *key )
1584 {
1585   int rc, nbits;
1586   gcry_sexp_t sexp;
1587
1588   if (algo == PUBKEY_ALGO_DSA
1589       && key[0] && key[1] && key[2] && key[3])
1590     {
1591       rc = gcry_sexp_build (&sexp, NULL,
1592                             "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1593                             key[0], key[1], key[2], key[3] );
1594     }
1595   else if ((algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E)
1596            && key[0] && key[1] && key[2])
1597     {
1598       rc = gcry_sexp_build (&sexp, NULL,
1599                             "(public-key(elg(p%m)(g%m)(y%m)))",
1600                             key[0], key[1], key[2] );
1601     }
1602   else if (is_RSA (algo)
1603            && key[0] && key[1])
1604     {
1605       rc = gcry_sexp_build (&sexp, NULL,
1606                             "(public-key(rsa(n%m)(e%m)))",
1607                             key[0], key[1] );
1608     }
1609   else if ((algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_ECDH
1610             || algo == PUBKEY_ALGO_EDDSA)
1611            && key[0] && key[1])
1612     {
1613       char *curve = openpgp_oid_to_str (key[0]);
1614       if (!curve)
1615         rc = gpg_error_from_syserror ();
1616       else
1617         {
1618           rc = gcry_sexp_build (&sexp, NULL,
1619                                 "(public-key(ecc(curve%s)(q%m)))",
1620                                 curve, key[1]);
1621           xfree (curve);
1622         }
1623     }
1624   else
1625     return 0;
1626
1627   if (rc)
1628     BUG ();
1629
1630   nbits = gcry_pk_get_nbits (sexp);
1631   gcry_sexp_release (sexp);
1632   return nbits;
1633 }
1634
1635
1636
1637 int
1638 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1639 {
1640   int n = 0;
1641   size_t nwritten;
1642
1643   if (!a)
1644     return es_fprintf (fp, "[MPI_NULL]");
1645   if (!mode)
1646     {
1647       unsigned int n1;
1648       n1 = gcry_mpi_get_nbits(a);
1649       n += es_fprintf (fp, "[%u bits]", n1);
1650     }
1651   else if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
1652     {
1653       unsigned int nbits;
1654       unsigned char *p = gcry_mpi_get_opaque (a, &nbits);
1655       if (!p)
1656         n += es_fprintf (fp, "[invalid opaque value]");
1657       else
1658         {
1659           if (!es_write_hexstring (fp, p, (nbits + 7)/8, 0, &nwritten))
1660             n += nwritten;
1661         }
1662     }
1663   else
1664     {
1665       unsigned char *buffer;
1666       size_t buflen;
1667
1668       if (gcry_mpi_aprint (GCRYMPI_FMT_USG, &buffer, &buflen, a))
1669         BUG ();
1670       if (!es_write_hexstring (fp, buffer, buflen, 0, &nwritten))
1671         n += nwritten;
1672       gcry_free (buffer);
1673     }
1674   return n;
1675 }
1676
1677
1678 /* pkey[1] or skey[1] is Q for ECDSA, which is an uncompressed point,
1679    i.e.  04 <x> <y> */
1680 unsigned int
1681 ecdsa_qbits_from_Q (unsigned int qbits)
1682 {
1683   if ((qbits%8) > 3)
1684     {
1685       log_error (_("ECDSA public key is expected to be in SEC encoding "
1686                    "multiple of 8 bits\n"));
1687       return 0;
1688     }
1689   qbits -= qbits%8;
1690   qbits /= 2;
1691   return qbits;
1692 }
1693
1694
1695 /* Ignore signatures and certifications made over certain digest
1696  * algorithms by default, MD5 is considered weak.  This allows users
1697  * to deprecate support for other algorithms as well.
1698  */
1699 void
1700 additional_weak_digest (const char* digestname)
1701 {
1702   struct weakhash *weak = NULL;
1703   const enum gcry_md_algos algo = string_to_digest_algo(digestname);
1704
1705   if (algo == GCRY_MD_NONE)
1706     {
1707       log_error(_("Unknown weak digest '%s'\n"), digestname);
1708       return;
1709     }
1710
1711   /* Check to ensure it's not already present.  */
1712   for (weak = opt.weak_digests; weak; weak = weak->next)
1713     if (algo == weak->algo)
1714       return;
1715
1716   /* Add it to the head of the list.  */
1717   weak = xmalloc(sizeof(*weak));
1718   weak->algo = algo;
1719   weak->rejection_shown = 0;
1720   weak->next = opt.weak_digests;
1721   opt.weak_digests = weak;
1722 }