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