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