320e8afbf741638df1eeb7982b4c6cd21d39341a
[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     case DIGEST_ALGO_SHA256: return GCRY_MD_SHA256;
690
691 #ifdef GPG_USE_SHA384
692     case DIGEST_ALGO_SHA384: return GCRY_MD_SHA384;
693 #else
694     case DIGEST_ALGO_SHA384: return 0;
695 #endif
696
697 #ifdef GPG_USE_SHA512
698     case DIGEST_ALGO_SHA512: return GCRY_MD_SHA512;
699 #else
700     case DIGEST_ALGO_SHA512: return 0;
701 #endif
702     }
703   return 0;
704 }
705
706
707 /* Return 0 if ALGO is suitable and implemented OpenPGP hash
708    algorithm.  */
709 int
710 openpgp_md_test_algo (digest_algo_t algo)
711 {
712   enum gcry_md_algos ga;
713
714   ga = map_md_openpgp_to_gcry (algo);
715   if (!ga)
716     return gpg_error (GPG_ERR_DIGEST_ALGO);
717
718   return gcry_md_test_algo (ga);
719 }
720
721
722 /* Map the OpenPGP digest algorithm whose ID is contained in ALGO to a
723    string representation of the algorithm name.  For unknown algorithm
724    IDs this function returns "?".  */
725 const char *
726 openpgp_md_algo_name (int algo)
727 {
728   switch (algo)
729     {
730     case DIGEST_ALGO_MD5:    return "MD5";
731     case DIGEST_ALGO_SHA1:   return "SHA1";
732     case DIGEST_ALGO_RMD160: return "RIPEMD160";
733     case DIGEST_ALGO_SHA256: return "SHA256";
734     case DIGEST_ALGO_SHA384: return "SHA384";
735     case DIGEST_ALGO_SHA512: return "SHA512";
736     case DIGEST_ALGO_SHA224: return "SHA224";
737     }
738   return "?";
739 }
740
741
742 static unsigned long
743 get_signature_count (PKT_public_key *pk)
744 {
745 #ifdef ENABLE_CARD_SUPPORT
746   struct agent_card_info_s info;
747
748   (void)pk;
749   if (!agent_scd_getattr ("SIG-COUNTER",&info))
750     return info.sig_counter;
751   else
752     return 0;
753 #else
754   (void)pk;
755   return 0;
756 #endif
757 }
758
759 /* Expand %-strings.  Returns a string which must be xfreed.  Returns
760    NULL if the string cannot be expanded (too large). */
761 char *
762 pct_expando(const char *string,struct expando_args *args)
763 {
764   const char *ch=string;
765   int idx=0,maxlen=0,done=0;
766   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
767   char *ret=NULL;
768
769   if(args->pk)
770     keyid_from_pk(args->pk,pk_keyid);
771
772   if(args->pksk)
773     keyid_from_pk (args->pksk, sk_keyid);
774
775   /* This is used so that %k works in photoid command strings in
776      --list-secret-keys (which of course has a sk, but no pk). */
777   if(!args->pk && args->pksk)
778     keyid_from_pk (args->pksk, pk_keyid);
779
780   while(*ch!='\0')
781     {
782       if(!done)
783         {
784           /* 8192 is way bigger than we'll need here */
785           if(maxlen>=8192)
786             goto fail;
787
788           maxlen+=1024;
789           ret=xrealloc(ret,maxlen);
790         }
791
792       done=0;
793
794       if(*ch=='%')
795         {
796           switch(*(ch+1))
797             {
798             case 's': /* short key id */
799               if(idx+8<maxlen)
800                 {
801                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
802                   idx+=8;
803                   done=1;
804                 }
805               break;
806
807             case 'S': /* long key id */
808               if(idx+16<maxlen)
809                 {
810                   sprintf(&ret[idx],"%08lX%08lX",
811                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
812                   idx+=16;
813                   done=1;
814                 }
815               break;
816
817             case 'k': /* short key id */
818               if(idx+8<maxlen)
819                 {
820                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
821                   idx+=8;
822                   done=1;
823                 }
824               break;
825
826             case 'K': /* long key id */
827               if(idx+16<maxlen)
828                 {
829                   sprintf(&ret[idx],"%08lX%08lX",
830                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
831                   idx+=16;
832                   done=1;
833                 }
834               break;
835
836             case 'U': /* z-base-32 encoded user id hash. */
837               if (args->namehash)
838                 {
839                   char *tmp = zb32_encode (args->namehash, 8*20);
840                   if (tmp)
841                     {
842                       if (idx + strlen (tmp) < maxlen)
843                         {
844                           strcpy (ret+idx, tmp);
845                           idx += strlen (tmp);
846                         }
847                       xfree (tmp);
848                       done = 1;
849                     }
850                 }
851               break;
852
853             case 'c': /* signature count from card, if any. */
854               if(idx+10<maxlen)
855                 {
856                   sprintf (&ret[idx],"%lu", get_signature_count (args->pksk));
857                   idx+=strlen(&ret[idx]);
858                   done=1;
859                 }
860               break;
861
862             case 'p': /* primary pk fingerprint of a sk */
863             case 'f': /* pk fingerprint */
864             case 'g': /* sk fingerprint */
865               {
866                 byte array[MAX_FINGERPRINT_LEN];
867                 size_t len;
868                 int i;
869
870                 if((*(ch+1))=='p' && args->pksk)
871                   {
872                     if(args->pksk->flags.primary)
873                       fingerprint_from_pk (args->pksk, array, &len);
874                     else if (args->pksk->main_keyid[0]
875                              || args->pksk->main_keyid[1])
876                       {
877                         /* FIXME: Document teh code and check whether
878                            it is still needed.  */
879                         PKT_public_key *pk=
880                           xmalloc_clear(sizeof(PKT_public_key));
881
882                         if (!get_pubkey_fast (pk,args->pksk->main_keyid))
883                           fingerprint_from_pk (pk, array, &len);
884                         else
885                           memset (array, 0, (len=MAX_FINGERPRINT_LEN));
886                         free_public_key (pk);
887                       }
888                     else
889                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
890                   }
891                 else if((*(ch+1))=='f' && args->pk)
892                   fingerprint_from_pk (args->pk, array, &len);
893                 else if((*(ch+1))=='g' && args->pksk)
894                   fingerprint_from_pk (args->pksk, array, &len);
895                 else
896                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
897
898                 if(idx+(len*2)<maxlen)
899                   {
900                     for(i=0;i<len;i++)
901                       {
902                         sprintf(&ret[idx],"%02X",array[i]);
903                         idx+=2;
904                       }
905                     done=1;
906                   }
907               }
908               break;
909
910             case 'v': /* validity letters */
911               if(args->validity_info && idx+1<maxlen)
912                 {
913                   ret[idx++]=args->validity_info;
914                   ret[idx]='\0';
915                   done=1;
916                 }
917               break;
918
919               /* The text string types */
920             case 't':
921             case 'T':
922             case 'V':
923               {
924                 const char *str=NULL;
925
926                 switch(*(ch+1))
927                   {
928                   case 't': /* e.g. "jpg" */
929                     str=image_type_to_string(args->imagetype,0);
930                     break;
931
932                   case 'T': /* e.g. "image/jpeg" */
933                     str=image_type_to_string(args->imagetype,2);
934                     break;
935
936                   case 'V': /* e.g. "full", "expired", etc. */
937                     str=args->validity_string;
938                     break;
939                   }
940
941                 if(str && idx+strlen(str)<maxlen)
942                   {
943                     strcpy(&ret[idx],str);
944                     idx+=strlen(str);
945                     done=1;
946                   }
947               }
948               break;
949
950             case '%':
951               if(idx+1<maxlen)
952                 {
953                   ret[idx++]='%';
954                   ret[idx]='\0';
955                   done=1;
956                 }
957               break;
958
959               /* Any unknown %-keys (like %i, %o, %I, and %O) are
960                  passed through for later expansion.  Note this also
961                  handles the case where the last character in the
962                  string is a '%' - the terminating \0 will end up here
963                  and properly terminate the string. */
964             default:
965               if(idx+2<maxlen)
966                 {
967                   ret[idx++]='%';
968                   ret[idx++]=*(ch+1);
969                   ret[idx]='\0';
970                   done=1;
971                 }
972               break;
973               }
974
975           if(done)
976             ch++;
977         }
978       else
979         {
980           if(idx+1<maxlen)
981             {
982               ret[idx++]=*ch;
983               ret[idx]='\0';
984               done=1;
985             }
986         }
987
988       if(done)
989         ch++;
990     }
991
992   return ret;
993
994  fail:
995   xfree(ret);
996   return NULL;
997 }
998
999 void
1000 deprecated_warning(const char *configname,unsigned int configlineno,
1001                    const char *option,const char *repl1,const char *repl2)
1002 {
1003   if(configname)
1004     {
1005       if(strncmp("--",option,2)==0)
1006         option+=2;
1007
1008       if(strncmp("--",repl1,2)==0)
1009         repl1+=2;
1010
1011       log_info(_("%s:%d: deprecated option \"%s\"\n"),
1012                configname,configlineno,option);
1013     }
1014   else
1015     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
1016
1017   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
1018 }
1019
1020
1021 void
1022 deprecated_command (const char *name)
1023 {
1024   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
1025            name);
1026 }
1027
1028
1029 void
1030 obsolete_option (const char *configname, unsigned int configlineno,
1031                  const char *name)
1032 {
1033   if(configname)
1034     log_info (_("%s:%u: obsolete option \"%s\" - it has no effect\n"),
1035               configname, configlineno, name);
1036   else
1037     log_info (_("WARNING: \"%s%s\" is an obsolete option - it has no effect\n"),
1038               "--", name);
1039 }
1040
1041
1042 void
1043 obsolete_scdaemon_option (const char *configname, unsigned int configlineno,
1044                           const char *name)
1045 {
1046   if (configname)
1047     log_info (_("%s:%u: \"%s\" is obsolete in this file"
1048                 " - it only has effect in %s\n"),
1049               configname, configlineno, name, SCDAEMON_NAME EXTSEP_S "conf");
1050   else
1051     log_info (_("WARNING: \"%s%s\" is an obsolete option"
1052                 " - it has no effect except on %s\n"),
1053               "--", name, SCDAEMON_NAME);
1054 }
1055
1056
1057 /*
1058  * Wrapper around gcry_cipher_map_name to provide a fallback using the
1059  * "Sn" syntax as used by the preference strings.
1060  */
1061 int
1062 string_to_cipher_algo (const char *string)
1063 {
1064   int val;
1065
1066   val = map_cipher_gcry_to_openpgp (gcry_cipher_map_name (string));
1067   if (!val && string && (string[0]=='S' || string[0]=='s'))
1068     {
1069       char *endptr;
1070
1071       string++;
1072       val = strtol (string, &endptr, 10);
1073       if (!*string || *endptr || openpgp_cipher_test_algo (val))
1074         val = 0;
1075     }
1076
1077   return val;
1078 }
1079
1080 /*
1081  * Wrapper around gcry_md_map_name to provide a fallback using the
1082  * "Hn" syntax as used by the preference strings.
1083  */
1084 int
1085 string_to_digest_algo (const char *string)
1086 {
1087   int val;
1088
1089   /* FIXME: We should make use of our wrapper fucntion and not assume
1090      that there is a 1 to 1 mapping between OpenPGP and Libgcrypt.  */
1091   val = gcry_md_map_name (string);
1092   if (!val && string && (string[0]=='H' || string[0]=='h'))
1093     {
1094       char *endptr;
1095
1096       string++;
1097       val = strtol (string, &endptr, 10);
1098       if (!*string || *endptr || openpgp_md_test_algo (val))
1099         val = 0;
1100     }
1101
1102   return val;
1103 }
1104
1105
1106
1107 const char *
1108 compress_algo_to_string(int algo)
1109 {
1110   const char *s=NULL;
1111
1112   switch(algo)
1113     {
1114     case COMPRESS_ALGO_NONE:
1115       s=_("Uncompressed");
1116       break;
1117
1118     case COMPRESS_ALGO_ZIP:
1119       s="ZIP";
1120       break;
1121
1122     case COMPRESS_ALGO_ZLIB:
1123       s="ZLIB";
1124       break;
1125
1126 #ifdef HAVE_BZIP2
1127     case COMPRESS_ALGO_BZIP2:
1128       s="BZIP2";
1129       break;
1130 #endif
1131     }
1132
1133   return s;
1134 }
1135
1136 int
1137 string_to_compress_algo(const char *string)
1138 {
1139   /* TRANSLATORS: See doc/TRANSLATE about this string. */
1140   if(match_multistr(_("uncompressed|none"),string))
1141     return 0;
1142   else if(ascii_strcasecmp(string,"uncompressed")==0)
1143     return 0;
1144   else if(ascii_strcasecmp(string,"none")==0)
1145     return 0;
1146   else if(ascii_strcasecmp(string,"zip")==0)
1147     return 1;
1148   else if(ascii_strcasecmp(string,"zlib")==0)
1149     return 2;
1150 #ifdef HAVE_BZIP2
1151   else if(ascii_strcasecmp(string,"bzip2")==0)
1152     return 3;
1153 #endif
1154   else if(ascii_strcasecmp(string,"z0")==0)
1155     return 0;
1156   else if(ascii_strcasecmp(string,"z1")==0)
1157     return 1;
1158   else if(ascii_strcasecmp(string,"z2")==0)
1159     return 2;
1160 #ifdef HAVE_BZIP2
1161   else if(ascii_strcasecmp(string,"z3")==0)
1162     return 3;
1163 #endif
1164   else
1165     return -1;
1166 }
1167
1168 int
1169 check_compress_algo(int algo)
1170 {
1171   switch (algo)
1172     {
1173     case 0: return 0;
1174 #ifdef HAVE_ZIP
1175     case 1:
1176     case 2: return 0;
1177 #endif
1178 #ifdef HAVE_BZIP2
1179     case 3: return 0;
1180 #endif
1181     default: return G10ERR_COMPR_ALGO;
1182     }
1183 }
1184
1185 int
1186 default_cipher_algo(void)
1187 {
1188   if(opt.def_cipher_algo)
1189     return opt.def_cipher_algo;
1190   else if(opt.personal_cipher_prefs)
1191     return opt.personal_cipher_prefs[0].value;
1192   else
1193     return opt.s2k_cipher_algo;
1194 }
1195
1196 /* There is no default_digest_algo function, but see
1197    sign.c:hash_for() */
1198
1199 int
1200 default_compress_algo(void)
1201 {
1202   if(opt.compress_algo!=-1)
1203     return opt.compress_algo;
1204   else if(opt.personal_compress_prefs)
1205     return opt.personal_compress_prefs[0].value;
1206   else
1207     return DEFAULT_COMPRESS_ALGO;
1208 }
1209
1210 const char *
1211 compliance_option_string(void)
1212 {
1213   char *ver="???";
1214
1215   switch(opt.compliance)
1216     {
1217     case CO_GNUPG:   return "--gnupg";
1218     case CO_RFC4880: return "--openpgp";
1219     case CO_RFC2440: return "--rfc2440";
1220     case CO_PGP6:    return "--pgp6";
1221     case CO_PGP7:    return "--pgp7";
1222     case CO_PGP8:    return "--pgp8";
1223     }
1224
1225   return ver;
1226 }
1227
1228 void
1229 compliance_failure(void)
1230 {
1231   char *ver="???";
1232
1233   switch(opt.compliance)
1234     {
1235     case CO_GNUPG:
1236       ver="GnuPG";
1237       break;
1238
1239     case CO_RFC4880:
1240       ver="OpenPGP";
1241       break;
1242
1243     case CO_RFC2440:
1244       ver="OpenPGP (older)";
1245       break;
1246
1247     case CO_PGP6:
1248       ver="PGP 6.x";
1249       break;
1250
1251     case CO_PGP7:
1252       ver="PGP 7.x";
1253       break;
1254
1255     case CO_PGP8:
1256       ver="PGP 8.x";
1257       break;
1258     }
1259
1260   log_info(_("this message may not be usable by %s\n"),ver);
1261   opt.compliance=CO_GNUPG;
1262 }
1263
1264 /* Break a string into successive option pieces.  Accepts single word
1265    options and key=value argument options. */
1266 char *
1267 optsep(char **stringp)
1268 {
1269   char *tok,*end;
1270
1271   tok=*stringp;
1272   if(tok)
1273     {
1274       end=strpbrk(tok," ,=");
1275       if(end)
1276         {
1277           int sawequals=0;
1278           char *ptr=end;
1279
1280           /* what we need to do now is scan along starting with *end,
1281              If the next character we see (ignoring spaces) is an =
1282              sign, then there is an argument. */
1283
1284           while(*ptr)
1285             {
1286               if(*ptr=='=')
1287                 sawequals=1;
1288               else if(*ptr!=' ')
1289                 break;
1290               ptr++;
1291             }
1292
1293           /* There is an argument, so grab that too.  At this point,
1294              ptr points to the first character of the argument. */
1295           if(sawequals)
1296             {
1297               /* Is it a quoted argument? */
1298               if(*ptr=='"')
1299                 {
1300                   ptr++;
1301                   end=strchr(ptr,'"');
1302                   if(end)
1303                     end++;
1304                 }
1305               else
1306                 end=strpbrk(ptr," ,");
1307             }
1308
1309           if(end && *end)
1310             {
1311               *end='\0';
1312               *stringp=end+1;
1313             }
1314           else
1315             *stringp=NULL;
1316         }
1317       else
1318         *stringp=NULL;
1319     }
1320
1321   return tok;
1322 }
1323
1324 /* Breaks an option value into key and value.  Returns NULL if there
1325    is no value.  Note that "string" is modified to remove the =value
1326    part. */
1327 char *
1328 argsplit(char *string)
1329 {
1330   char *equals,*arg=NULL;
1331
1332   equals=strchr(string,'=');
1333   if(equals)
1334     {
1335       char *quote,*space;
1336
1337       *equals='\0';
1338       arg=equals+1;
1339
1340       /* Quoted arg? */
1341       quote=strchr(arg,'"');
1342       if(quote)
1343         {
1344           arg=quote+1;
1345
1346           quote=strchr(arg,'"');
1347           if(quote)
1348             *quote='\0';
1349         }
1350       else
1351         {
1352           size_t spaces;
1353
1354           /* Trim leading spaces off of the arg */
1355           spaces=strspn(arg," ");
1356           arg+=spaces;
1357         }
1358
1359       /* Trim tailing spaces off of the tag */
1360       space=strchr(string,' ');
1361       if(space)
1362         *space='\0';
1363     }
1364
1365   return arg;
1366 }
1367
1368 /* Return the length of the initial token, leaving off any
1369    argument. */
1370 static size_t
1371 optlen(const char *s)
1372 {
1373   char *end=strpbrk(s," =");
1374
1375   if(end)
1376     return end-s;
1377   else
1378     return strlen(s);
1379 }
1380
1381 int
1382 parse_options(char *str,unsigned int *options,
1383               struct parse_options *opts,int noisy)
1384 {
1385   char *tok;
1386
1387   if (str && !strcmp (str, "help"))
1388     {
1389       int i,maxlen=0;
1390
1391       /* Figure out the longest option name so we can line these up
1392          neatly. */
1393       for(i=0;opts[i].name;i++)
1394         if(opts[i].help && maxlen<strlen(opts[i].name))
1395           maxlen=strlen(opts[i].name);
1396
1397       for(i=0;opts[i].name;i++)
1398         if(opts[i].help)
1399           printf("%s%*s%s\n",opts[i].name,
1400                  maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1401
1402       g10_exit(0);
1403     }
1404
1405   while((tok=optsep(&str)))
1406     {
1407       int i,rev=0;
1408       char *otok=tok;
1409
1410       if(tok[0]=='\0')
1411         continue;
1412
1413       if(ascii_strncasecmp("no-",tok,3)==0)
1414         {
1415           rev=1;
1416           tok+=3;
1417         }
1418
1419       for(i=0;opts[i].name;i++)
1420         {
1421           size_t toklen=optlen(tok);
1422
1423           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1424             {
1425               /* We have a match, but it might be incomplete */
1426               if(toklen!=strlen(opts[i].name))
1427                 {
1428                   int j;
1429
1430                   for(j=i+1;opts[j].name;j++)
1431                     {
1432                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1433                         {
1434                           if(noisy)
1435                             log_info(_("ambiguous option '%s'\n"),otok);
1436                           return 0;
1437                         }
1438                     }
1439                 }
1440
1441               if(rev)
1442                 {
1443                   *options&=~opts[i].bit;
1444                   if(opts[i].value)
1445                     *opts[i].value=NULL;
1446                 }
1447               else
1448                 {
1449                   *options|=opts[i].bit;
1450                   if(opts[i].value)
1451                     *opts[i].value=argsplit(tok);
1452                 }
1453               break;
1454             }
1455         }
1456
1457       if(!opts[i].name)
1458         {
1459           if(noisy)
1460             log_info(_("unknown option '%s'\n"),otok);
1461           return 0;
1462         }
1463     }
1464
1465   return 1;
1466 }
1467
1468
1469 /* Check whether the string has characters not valid in an RFC-822
1470    address.  To cope with OpenPGP we ignore non-ascii characters
1471    so that for example umlauts are legal in an email address.  An
1472    OpenPGP user ID must be utf-8 encoded but there is no strict
1473    requirement for RFC-822.  Thus to avoid IDNA encoding we put the
1474    address verbatim as utf-8 into the user ID under the assumption
1475    that mail programs handle IDNA at a lower level and take OpenPGP
1476    user IDs as utf-8.  Note that we can't do an utf-8 encoding
1477    checking here because in keygen.c this function is called with the
1478    native encoding and native to utf-8 encoding is only done  later.  */
1479 int
1480 has_invalid_email_chars (const char *s)
1481 {
1482   int at_seen=0;
1483   const char *valid_chars=
1484     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1485
1486   for ( ; *s; s++ )
1487     {
1488       if ( (*s & 0x80) )
1489         continue; /* We only care about ASCII.  */
1490       if ( *s == '@' )
1491         at_seen=1;
1492       else if ( !at_seen && !(strchr (valid_chars, *s)
1493                               || strchr ("!#$%&'*+/=?^`{|}~", *s)))
1494         return 1;
1495       else if ( at_seen && !strchr( valid_chars, *s ) )
1496         return 1;
1497     }
1498   return 0;
1499 }
1500
1501
1502 /* Check whether NAME represents a valid mailbox according to
1503    RFC822. Returns true if so. */
1504 int
1505 is_valid_mailbox (const char *name)
1506 {
1507   return !( !name
1508             || !*name
1509             || has_invalid_email_chars (name)
1510             || string_count_chr (name,'@') != 1
1511             || *name == '@'
1512             || name[strlen(name)-1] == '@'
1513             || name[strlen(name)-1] == '.'
1514             || strstr (name, "..") );
1515 }
1516
1517
1518 /* Check whether UID is a valid standard user id of the form
1519      "Heinrich Heine <heinrichh@duesseldorf.de>"
1520    and return true if this is the case. */
1521 int
1522 is_valid_user_id (const char *uid)
1523 {
1524   if (!uid || !*uid)
1525     return 0;
1526
1527   return 1;
1528 }
1529
1530
1531
1532 /* Similar to access(2), but uses PATH to find the file. */
1533 int
1534 path_access(const char *file,int mode)
1535 {
1536   char *envpath;
1537   int ret=-1;
1538
1539   envpath=getenv("PATH");
1540
1541   if(!envpath
1542 #ifdef HAVE_DRIVE_LETTERS
1543      || (((file[0]>='A' && file[0]<='Z')
1544           || (file[0]>='a' && file[0]<='z'))
1545          && file[1]==':')
1546 #else
1547      || file[0]=='/'
1548 #endif
1549      )
1550     return access(file,mode);
1551   else
1552     {
1553       /* At least as large as, but most often larger than we need. */
1554       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1555       char *split,*item,*path=xstrdup(envpath);
1556
1557       split=path;
1558
1559       while((item=strsep(&split,PATHSEP_S)))
1560         {
1561           strcpy(buffer,item);
1562           strcat(buffer,"/");
1563           strcat(buffer,file);
1564           ret=access(buffer,mode);
1565           if(ret==0)
1566             break;
1567         }
1568
1569       xfree(path);
1570       xfree(buffer);
1571     }
1572
1573   return ret;
1574 }
1575
1576
1577 \f
1578 /* Return the number of public key parameters as used by OpenPGP.  */
1579 int
1580 pubkey_get_npkey (pubkey_algo_t algo)
1581 {
1582   switch (algo)
1583     {
1584     case PUBKEY_ALGO_RSA:
1585     case PUBKEY_ALGO_RSA_E:
1586     case PUBKEY_ALGO_RSA_S:     return 2;
1587     case PUBKEY_ALGO_ELGAMAL_E: return 3;
1588     case PUBKEY_ALGO_DSA:       return 4;
1589     case PUBKEY_ALGO_ECDH:      return 3;
1590     case PUBKEY_ALGO_ECDSA:     return 2;
1591     case PUBKEY_ALGO_ELGAMAL:   return 3;
1592     case PUBKEY_ALGO_EDDSA:     return 2;
1593     }
1594   return 0;
1595 }
1596
1597
1598 /* Return the number of secret key parameters as used by OpenPGP.  */
1599 int
1600 pubkey_get_nskey (pubkey_algo_t algo)
1601 {
1602   switch (algo)
1603     {
1604     case PUBKEY_ALGO_RSA:
1605     case PUBKEY_ALGO_RSA_E:
1606     case PUBKEY_ALGO_RSA_S:     return 6;
1607     case PUBKEY_ALGO_ELGAMAL_E: return 4;
1608     case PUBKEY_ALGO_DSA:       return 5;
1609     case PUBKEY_ALGO_ECDH:      return 4;
1610     case PUBKEY_ALGO_ECDSA:     return 3;
1611     case PUBKEY_ALGO_ELGAMAL:   return 4;
1612     case PUBKEY_ALGO_EDDSA:     return 3;
1613     }
1614   return 0;
1615 }
1616
1617 /* Temporary helper. */
1618 int
1619 pubkey_get_nsig (pubkey_algo_t algo)
1620 {
1621   switch (algo)
1622     {
1623     case PUBKEY_ALGO_RSA:
1624     case PUBKEY_ALGO_RSA_E:
1625     case PUBKEY_ALGO_RSA_S:     return 1;
1626     case PUBKEY_ALGO_ELGAMAL_E: return 0;
1627     case PUBKEY_ALGO_DSA:       return 2;
1628     case PUBKEY_ALGO_ECDH:      return 0;
1629     case PUBKEY_ALGO_ECDSA:     return 2;
1630     case PUBKEY_ALGO_ELGAMAL:   return 2;
1631     case PUBKEY_ALGO_EDDSA:     return 2;
1632     }
1633   return 0;
1634 }
1635
1636
1637 /* Temporary helper. */
1638 int
1639 pubkey_get_nenc (pubkey_algo_t algo)
1640 {
1641   switch (algo)
1642     {
1643     case PUBKEY_ALGO_RSA:
1644     case PUBKEY_ALGO_RSA_E:
1645     case PUBKEY_ALGO_RSA_S:     return 1;
1646     case PUBKEY_ALGO_ELGAMAL_E: return 2;
1647     case PUBKEY_ALGO_DSA:       return 0;
1648     case PUBKEY_ALGO_ECDH:      return 2;
1649     case PUBKEY_ALGO_ECDSA:     return 0;
1650     case PUBKEY_ALGO_ELGAMAL:   return 2;
1651     case PUBKEY_ALGO_EDDSA:     return 0;
1652     }
1653   return 0;
1654 }
1655
1656
1657 /* Temporary helper. */
1658 unsigned int
1659 pubkey_nbits( int algo, gcry_mpi_t *key )
1660 {
1661   int rc, nbits;
1662   gcry_sexp_t sexp;
1663
1664   if (algo == PUBKEY_ALGO_DSA
1665       && key[0] && key[1] && key[2] && key[3])
1666     {
1667       rc = gcry_sexp_build (&sexp, NULL,
1668                             "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1669                             key[0], key[1], key[2], key[3] );
1670     }
1671   else if ((algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E)
1672            && key[0] && key[1] && key[2])
1673     {
1674       rc = gcry_sexp_build (&sexp, NULL,
1675                             "(public-key(elg(p%m)(g%m)(y%m)))",
1676                             key[0], key[1], key[2] );
1677     }
1678   else if (is_RSA (algo)
1679            && key[0] && key[1])
1680     {
1681       rc = gcry_sexp_build (&sexp, NULL,
1682                             "(public-key(rsa(n%m)(e%m)))",
1683                             key[0], key[1] );
1684     }
1685   else if ((algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_ECDH
1686             || algo == PUBKEY_ALGO_EDDSA)
1687            && key[0] && key[1])
1688     {
1689       char *curve = openpgp_oid_to_str (key[0]);
1690       if (!curve)
1691         rc = gpg_error_from_syserror ();
1692       else
1693         {
1694           rc = gcry_sexp_build (&sexp, NULL,
1695                                 "(public-key(ecc(curve%s)(q%m)))",
1696                                 curve, key[1]);
1697           xfree (curve);
1698         }
1699     }
1700   else
1701     return 0;
1702
1703   if (rc)
1704     BUG ();
1705
1706   nbits = gcry_pk_get_nbits (sexp);
1707   gcry_sexp_release (sexp);
1708   return nbits;
1709 }
1710
1711
1712
1713 int
1714 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1715 {
1716   int n=0;
1717
1718   if (!a)
1719     return es_fprintf (fp, "[MPI_NULL]");
1720   if (!mode)
1721     {
1722       unsigned int n1;
1723       n1 = gcry_mpi_get_nbits(a);
1724       n += es_fprintf (fp, "[%u bits]", n1);
1725     }
1726   else if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
1727     {
1728       unsigned int nbits;
1729       unsigned char *p = gcry_mpi_get_opaque (a, &nbits);
1730       if (!p)
1731         n += es_fprintf (fp, "[invalid opaque value]");
1732       else
1733         {
1734           nbits = (nbits + 7)/8;
1735           for (; nbits; nbits--, p++)
1736             n += es_fprintf (fp, "%02X", *p);
1737         }
1738     }
1739   else
1740     {
1741       unsigned char *buffer;
1742
1743       if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a))
1744         BUG ();
1745       es_fputs (buffer, fp);
1746       n += strlen (buffer);
1747       gcry_free (buffer);
1748     }
1749   return n;
1750 }
1751
1752
1753 /* pkey[1] or skey[1] is Q for ECDSA, which is an uncompressed point,
1754    i.e.  04 <x> <y> */
1755 unsigned int
1756 ecdsa_qbits_from_Q (unsigned int qbits)
1757 {
1758   if ((qbits%8) > 3)
1759     {
1760       log_error (_("ECDSA public key is expected to be in SEC encoding "
1761                    "multiple of 8 bits\n"));
1762       return 0;
1763     }
1764   qbits -= qbits%8;
1765   qbits /= 2;
1766   return qbits;
1767 }