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