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