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