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