speedo: Improve speedo Makefile.
[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 /*
1047  * Wrapper around gcry_cipher_map_name to provide a fallback using the
1048  * "Sn" syntax as used by the preference strings.
1049  */
1050 int
1051 string_to_cipher_algo (const char *string)
1052 {
1053   int val;
1054
1055   val = map_cipher_gcry_to_openpgp (gcry_cipher_map_name (string));
1056   if (!val && string && (string[0]=='S' || string[0]=='s'))
1057     {
1058       char *endptr;
1059
1060       string++;
1061       val = strtol (string, &endptr, 10);
1062       if (!*string || *endptr || openpgp_cipher_test_algo (val))
1063         val = 0;
1064     }
1065
1066   return val;
1067 }
1068
1069 /*
1070  * Wrapper around gcry_md_map_name to provide a fallback using the
1071  * "Hn" syntax as used by the preference strings.
1072  */
1073 int
1074 string_to_digest_algo (const char *string)
1075 {
1076   int val;
1077
1078   /* FIXME: We should make use of our wrapper fucntion and not assume
1079      that there is a 1 to 1 mapping between OpenPGP and Libgcrypt.  */
1080   val = gcry_md_map_name (string);
1081   if (!val && string && (string[0]=='H' || string[0]=='h'))
1082     {
1083       char *endptr;
1084
1085       string++;
1086       val = strtol (string, &endptr, 10);
1087       if (!*string || *endptr || openpgp_md_test_algo (val))
1088         val = 0;
1089     }
1090
1091   return val;
1092 }
1093
1094
1095
1096 const char *
1097 compress_algo_to_string(int algo)
1098 {
1099   const char *s=NULL;
1100
1101   switch(algo)
1102     {
1103     case COMPRESS_ALGO_NONE:
1104       s=_("Uncompressed");
1105       break;
1106
1107     case COMPRESS_ALGO_ZIP:
1108       s="ZIP";
1109       break;
1110
1111     case COMPRESS_ALGO_ZLIB:
1112       s="ZLIB";
1113       break;
1114
1115 #ifdef HAVE_BZIP2
1116     case COMPRESS_ALGO_BZIP2:
1117       s="BZIP2";
1118       break;
1119 #endif
1120     }
1121
1122   return s;
1123 }
1124
1125 int
1126 string_to_compress_algo(const char *string)
1127 {
1128   /* TRANSLATORS: See doc/TRANSLATE about this string. */
1129   if(match_multistr(_("uncompressed|none"),string))
1130     return 0;
1131   else if(ascii_strcasecmp(string,"uncompressed")==0)
1132     return 0;
1133   else if(ascii_strcasecmp(string,"none")==0)
1134     return 0;
1135   else if(ascii_strcasecmp(string,"zip")==0)
1136     return 1;
1137   else if(ascii_strcasecmp(string,"zlib")==0)
1138     return 2;
1139 #ifdef HAVE_BZIP2
1140   else if(ascii_strcasecmp(string,"bzip2")==0)
1141     return 3;
1142 #endif
1143   else if(ascii_strcasecmp(string,"z0")==0)
1144     return 0;
1145   else if(ascii_strcasecmp(string,"z1")==0)
1146     return 1;
1147   else if(ascii_strcasecmp(string,"z2")==0)
1148     return 2;
1149 #ifdef HAVE_BZIP2
1150   else if(ascii_strcasecmp(string,"z3")==0)
1151     return 3;
1152 #endif
1153   else
1154     return -1;
1155 }
1156
1157 int
1158 check_compress_algo(int algo)
1159 {
1160   switch (algo)
1161     {
1162     case 0: return 0;
1163 #ifdef HAVE_ZIP
1164     case 1:
1165     case 2: return 0;
1166 #endif
1167 #ifdef HAVE_BZIP2
1168     case 3: return 0;
1169 #endif
1170     default: return G10ERR_COMPR_ALGO;
1171     }
1172 }
1173
1174 int
1175 default_cipher_algo(void)
1176 {
1177   if(opt.def_cipher_algo)
1178     return opt.def_cipher_algo;
1179   else if(opt.personal_cipher_prefs)
1180     return opt.personal_cipher_prefs[0].value;
1181   else
1182     return opt.s2k_cipher_algo;
1183 }
1184
1185 /* There is no default_digest_algo function, but see
1186    sign.c:hash_for() */
1187
1188 int
1189 default_compress_algo(void)
1190 {
1191   if(opt.compress_algo!=-1)
1192     return opt.compress_algo;
1193   else if(opt.personal_compress_prefs)
1194     return opt.personal_compress_prefs[0].value;
1195   else
1196     return DEFAULT_COMPRESS_ALGO;
1197 }
1198
1199 const char *
1200 compliance_option_string(void)
1201 {
1202   char *ver="???";
1203
1204   switch(opt.compliance)
1205     {
1206     case CO_GNUPG:   return "--gnupg";
1207     case CO_RFC4880: return "--openpgp";
1208     case CO_RFC2440: return "--rfc2440";
1209     case CO_PGP6:    return "--pgp6";
1210     case CO_PGP7:    return "--pgp7";
1211     case CO_PGP8:    return "--pgp8";
1212     }
1213
1214   return ver;
1215 }
1216
1217 void
1218 compliance_failure(void)
1219 {
1220   char *ver="???";
1221
1222   switch(opt.compliance)
1223     {
1224     case CO_GNUPG:
1225       ver="GnuPG";
1226       break;
1227
1228     case CO_RFC4880:
1229       ver="OpenPGP";
1230       break;
1231
1232     case CO_RFC2440:
1233       ver="OpenPGP (older)";
1234       break;
1235
1236     case CO_PGP6:
1237       ver="PGP 6.x";
1238       break;
1239
1240     case CO_PGP7:
1241       ver="PGP 7.x";
1242       break;
1243
1244     case CO_PGP8:
1245       ver="PGP 8.x";
1246       break;
1247     }
1248
1249   log_info(_("this message may not be usable by %s\n"),ver);
1250   opt.compliance=CO_GNUPG;
1251 }
1252
1253 /* Break a string into successive option pieces.  Accepts single word
1254    options and key=value argument options. */
1255 char *
1256 optsep(char **stringp)
1257 {
1258   char *tok,*end;
1259
1260   tok=*stringp;
1261   if(tok)
1262     {
1263       end=strpbrk(tok," ,=");
1264       if(end)
1265         {
1266           int sawequals=0;
1267           char *ptr=end;
1268
1269           /* what we need to do now is scan along starting with *end,
1270              If the next character we see (ignoring spaces) is an =
1271              sign, then there is an argument. */
1272
1273           while(*ptr)
1274             {
1275               if(*ptr=='=')
1276                 sawequals=1;
1277               else if(*ptr!=' ')
1278                 break;
1279               ptr++;
1280             }
1281
1282           /* There is an argument, so grab that too.  At this point,
1283              ptr points to the first character of the argument. */
1284           if(sawequals)
1285             {
1286               /* Is it a quoted argument? */
1287               if(*ptr=='"')
1288                 {
1289                   ptr++;
1290                   end=strchr(ptr,'"');
1291                   if(end)
1292                     end++;
1293                 }
1294               else
1295                 end=strpbrk(ptr," ,");
1296             }
1297
1298           if(end && *end)
1299             {
1300               *end='\0';
1301               *stringp=end+1;
1302             }
1303           else
1304             *stringp=NULL;
1305         }
1306       else
1307         *stringp=NULL;
1308     }
1309
1310   return tok;
1311 }
1312
1313 /* Breaks an option value into key and value.  Returns NULL if there
1314    is no value.  Note that "string" is modified to remove the =value
1315    part. */
1316 char *
1317 argsplit(char *string)
1318 {
1319   char *equals,*arg=NULL;
1320
1321   equals=strchr(string,'=');
1322   if(equals)
1323     {
1324       char *quote,*space;
1325
1326       *equals='\0';
1327       arg=equals+1;
1328
1329       /* Quoted arg? */
1330       quote=strchr(arg,'"');
1331       if(quote)
1332         {
1333           arg=quote+1;
1334
1335           quote=strchr(arg,'"');
1336           if(quote)
1337             *quote='\0';
1338         }
1339       else
1340         {
1341           size_t spaces;
1342
1343           /* Trim leading spaces off of the arg */
1344           spaces=strspn(arg," ");
1345           arg+=spaces;
1346         }
1347
1348       /* Trim tailing spaces off of the tag */
1349       space=strchr(string,' ');
1350       if(space)
1351         *space='\0';
1352     }
1353
1354   return arg;
1355 }
1356
1357 /* Return the length of the initial token, leaving off any
1358    argument. */
1359 static size_t
1360 optlen(const char *s)
1361 {
1362   char *end=strpbrk(s," =");
1363
1364   if(end)
1365     return end-s;
1366   else
1367     return strlen(s);
1368 }
1369
1370 int
1371 parse_options(char *str,unsigned int *options,
1372               struct parse_options *opts,int noisy)
1373 {
1374   char *tok;
1375
1376   if (str && !strcmp (str, "help"))
1377     {
1378       int i,maxlen=0;
1379
1380       /* Figure out the longest option name so we can line these up
1381          neatly. */
1382       for(i=0;opts[i].name;i++)
1383         if(opts[i].help && maxlen<strlen(opts[i].name))
1384           maxlen=strlen(opts[i].name);
1385
1386       for(i=0;opts[i].name;i++)
1387         if(opts[i].help)
1388           printf("%s%*s%s\n",opts[i].name,
1389                  maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1390
1391       g10_exit(0);
1392     }
1393
1394   while((tok=optsep(&str)))
1395     {
1396       int i,rev=0;
1397       char *otok=tok;
1398
1399       if(tok[0]=='\0')
1400         continue;
1401
1402       if(ascii_strncasecmp("no-",tok,3)==0)
1403         {
1404           rev=1;
1405           tok+=3;
1406         }
1407
1408       for(i=0;opts[i].name;i++)
1409         {
1410           size_t toklen=optlen(tok);
1411
1412           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1413             {
1414               /* We have a match, but it might be incomplete */
1415               if(toklen!=strlen(opts[i].name))
1416                 {
1417                   int j;
1418
1419                   for(j=i+1;opts[j].name;j++)
1420                     {
1421                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1422                         {
1423                           if(noisy)
1424                             log_info(_("ambiguous option '%s'\n"),otok);
1425                           return 0;
1426                         }
1427                     }
1428                 }
1429
1430               if(rev)
1431                 {
1432                   *options&=~opts[i].bit;
1433                   if(opts[i].value)
1434                     *opts[i].value=NULL;
1435                 }
1436               else
1437                 {
1438                   *options|=opts[i].bit;
1439                   if(opts[i].value)
1440                     *opts[i].value=argsplit(tok);
1441                 }
1442               break;
1443             }
1444         }
1445
1446       if(!opts[i].name)
1447         {
1448           if(noisy)
1449             log_info(_("unknown option '%s'\n"),otok);
1450           return 0;
1451         }
1452     }
1453
1454   return 1;
1455 }
1456
1457
1458 /* Check whether the string has characters not valid in an RFC-822
1459    address.  To cope with OpenPGP we ignore non-ascii characters
1460    so that for example umlauts are legal in an email address.  An
1461    OpenPGP user ID must be utf-8 encoded but there is no strict
1462    requirement for RFC-822.  Thus to avoid IDNA encoding we put the
1463    address verbatim as utf-8 into the user ID under the assumption
1464    that mail programs handle IDNA at a lower level and take OpenPGP
1465    user IDs as utf-8.  Note that we can't do an utf-8 encoding
1466    checking here because in keygen.c this function is called with the
1467    native encoding and native to utf-8 encoding is only done  later.  */
1468 int
1469 has_invalid_email_chars (const char *s)
1470 {
1471   int at_seen=0;
1472   const char *valid_chars=
1473     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1474
1475   for ( ; *s; s++ )
1476     {
1477       if ( (*s & 0x80) )
1478         continue; /* We only care about ASCII.  */
1479       if ( *s == '@' )
1480         at_seen=1;
1481       else if ( !at_seen && !(strchr (valid_chars, *s)
1482                               || strchr ("!#$%&'*+/=?^`{|}~", *s)))
1483         return 1;
1484       else if ( at_seen && !strchr( valid_chars, *s ) )
1485         return 1;
1486     }
1487   return 0;
1488 }
1489
1490
1491 /* Check whether NAME represents a valid mailbox according to
1492    RFC822. Returns true if so. */
1493 int
1494 is_valid_mailbox (const char *name)
1495 {
1496   return !( !name
1497             || !*name
1498             || has_invalid_email_chars (name)
1499             || string_count_chr (name,'@') != 1
1500             || *name == '@'
1501             || name[strlen(name)-1] == '@'
1502             || name[strlen(name)-1] == '.'
1503             || strstr (name, "..") );
1504 }
1505
1506
1507 /* Check whether UID is a valid standard user id of the form
1508      "Heinrich Heine <heinrichh@duesseldorf.de>"
1509    and return true if this is the case. */
1510 int
1511 is_valid_user_id (const char *uid)
1512 {
1513   if (!uid || !*uid)
1514     return 0;
1515
1516   return 1;
1517 }
1518
1519
1520
1521 /* Similar to access(2), but uses PATH to find the file. */
1522 int
1523 path_access(const char *file,int mode)
1524 {
1525   char *envpath;
1526   int ret=-1;
1527
1528   envpath=getenv("PATH");
1529
1530   if(!envpath
1531 #ifdef HAVE_DRIVE_LETTERS
1532      || (((file[0]>='A' && file[0]<='Z')
1533           || (file[0]>='a' && file[0]<='z'))
1534          && file[1]==':')
1535 #else
1536      || file[0]=='/'
1537 #endif
1538      )
1539     return access(file,mode);
1540   else
1541     {
1542       /* At least as large as, but most often larger than we need. */
1543       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1544       char *split,*item,*path=xstrdup(envpath);
1545
1546       split=path;
1547
1548       while((item=strsep(&split,PATHSEP_S)))
1549         {
1550           strcpy(buffer,item);
1551           strcat(buffer,"/");
1552           strcat(buffer,file);
1553           ret=access(buffer,mode);
1554           if(ret==0)
1555             break;
1556         }
1557
1558       xfree(path);
1559       xfree(buffer);
1560     }
1561
1562   return ret;
1563 }
1564
1565
1566 \f
1567 /* Return the number of public key parameters as used by OpenPGP.  */
1568 int
1569 pubkey_get_npkey (pubkey_algo_t algo)
1570 {
1571   switch (algo)
1572     {
1573     case PUBKEY_ALGO_RSA:
1574     case PUBKEY_ALGO_RSA_E:
1575     case PUBKEY_ALGO_RSA_S:     return 2;
1576     case PUBKEY_ALGO_ELGAMAL_E: return 3;
1577     case PUBKEY_ALGO_DSA:       return 4;
1578     case PUBKEY_ALGO_ECDH:      return 3;
1579     case PUBKEY_ALGO_ECDSA:     return 2;
1580     case PUBKEY_ALGO_ELGAMAL:   return 3;
1581     case PUBKEY_ALGO_EDDSA:     return 2;
1582     }
1583   return 0;
1584 }
1585
1586
1587 /* Return the number of secret key parameters as used by OpenPGP.  */
1588 int
1589 pubkey_get_nskey (pubkey_algo_t algo)
1590 {
1591   switch (algo)
1592     {
1593     case PUBKEY_ALGO_RSA:
1594     case PUBKEY_ALGO_RSA_E:
1595     case PUBKEY_ALGO_RSA_S:     return 6;
1596     case PUBKEY_ALGO_ELGAMAL_E: return 4;
1597     case PUBKEY_ALGO_DSA:       return 5;
1598     case PUBKEY_ALGO_ECDH:      return 4;
1599     case PUBKEY_ALGO_ECDSA:     return 3;
1600     case PUBKEY_ALGO_ELGAMAL:   return 4;
1601     case PUBKEY_ALGO_EDDSA:     return 3;
1602     }
1603   return 0;
1604 }
1605
1606 /* Temporary helper. */
1607 int
1608 pubkey_get_nsig (pubkey_algo_t algo)
1609 {
1610   switch (algo)
1611     {
1612     case PUBKEY_ALGO_RSA:
1613     case PUBKEY_ALGO_RSA_E:
1614     case PUBKEY_ALGO_RSA_S:     return 1;
1615     case PUBKEY_ALGO_ELGAMAL_E: return 0;
1616     case PUBKEY_ALGO_DSA:       return 2;
1617     case PUBKEY_ALGO_ECDH:      return 0;
1618     case PUBKEY_ALGO_ECDSA:     return 2;
1619     case PUBKEY_ALGO_ELGAMAL:   return 2;
1620     case PUBKEY_ALGO_EDDSA:     return 2;
1621     }
1622   return 0;
1623 }
1624
1625
1626 /* Temporary helper. */
1627 int
1628 pubkey_get_nenc (pubkey_algo_t algo)
1629 {
1630   switch (algo)
1631     {
1632     case PUBKEY_ALGO_RSA:
1633     case PUBKEY_ALGO_RSA_E:
1634     case PUBKEY_ALGO_RSA_S:     return 1;
1635     case PUBKEY_ALGO_ELGAMAL_E: return 2;
1636     case PUBKEY_ALGO_DSA:       return 0;
1637     case PUBKEY_ALGO_ECDH:      return 2;
1638     case PUBKEY_ALGO_ECDSA:     return 0;
1639     case PUBKEY_ALGO_ELGAMAL:   return 2;
1640     case PUBKEY_ALGO_EDDSA:     return 0;
1641     }
1642   return 0;
1643 }
1644
1645
1646 /* Temporary helper. */
1647 unsigned int
1648 pubkey_nbits( int algo, gcry_mpi_t *key )
1649 {
1650   int rc, nbits;
1651   gcry_sexp_t sexp;
1652
1653   if (algo == PUBKEY_ALGO_DSA
1654       && key[0] && key[1] && key[2] && key[3])
1655     {
1656       rc = gcry_sexp_build (&sexp, NULL,
1657                             "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1658                             key[0], key[1], key[2], key[3] );
1659     }
1660   else if ((algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E)
1661            && key[0] && key[1] && key[2])
1662     {
1663       rc = gcry_sexp_build (&sexp, NULL,
1664                             "(public-key(elg(p%m)(g%m)(y%m)))",
1665                             key[0], key[1], key[2] );
1666     }
1667   else if (is_RSA (algo)
1668            && key[0] && key[1])
1669     {
1670       rc = gcry_sexp_build (&sexp, NULL,
1671                             "(public-key(rsa(n%m)(e%m)))",
1672                             key[0], key[1] );
1673     }
1674   else if ((algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_ECDH
1675             || algo == PUBKEY_ALGO_EDDSA)
1676            && key[0] && key[1])
1677     {
1678       char *curve = openpgp_oid_to_str (key[0]);
1679       if (!curve)
1680         rc = gpg_error_from_syserror ();
1681       else
1682         {
1683           rc = gcry_sexp_build (&sexp, NULL,
1684                                 "(public-key(ecc(curve%s)(q%m)))",
1685                                 curve, key[1]);
1686           xfree (curve);
1687         }
1688     }
1689   else
1690     return 0;
1691
1692   if (rc)
1693     BUG ();
1694
1695   nbits = gcry_pk_get_nbits (sexp);
1696   gcry_sexp_release (sexp);
1697   return nbits;
1698 }
1699
1700
1701
1702 int
1703 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1704 {
1705   int n=0;
1706
1707   if (!a)
1708     return es_fprintf (fp, "[MPI_NULL]");
1709   if (!mode)
1710     {
1711       unsigned int n1;
1712       n1 = gcry_mpi_get_nbits(a);
1713       n += es_fprintf (fp, "[%u bits]", n1);
1714     }
1715   else if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
1716     {
1717       unsigned int nbits;
1718       unsigned char *p = gcry_mpi_get_opaque (a, &nbits);
1719       if (!p)
1720         n += es_fprintf (fp, "[invalid opaque value]");
1721       else
1722         {
1723           nbits = (nbits + 7)/8;
1724           for (; nbits; nbits--, p++)
1725             n += es_fprintf (fp, "%02X", *p);
1726         }
1727     }
1728   else
1729     {
1730       unsigned char *buffer;
1731
1732       if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a))
1733         BUG ();
1734       es_fputs (buffer, fp);
1735       n += strlen (buffer);
1736       gcry_free (buffer);
1737     }
1738   return n;
1739 }
1740
1741
1742 /* pkey[1] or skey[1] is Q for ECDSA, which is an uncompressed point,
1743    i.e.  04 <x> <y> */
1744 unsigned int
1745 ecdsa_qbits_from_Q (unsigned int qbits)
1746 {
1747   if ((qbits%8) > 3)
1748     {
1749       log_error (_("ECDSA public key is expected to be in SEC encoding "
1750                    "multiple of 8 bits\n"));
1751       return 0;
1752     }
1753   qbits -= qbits%8;
1754   qbits /= 2;
1755   return qbits;
1756 }