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