gpg: Unify AEAD parameter retrieval.
[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   switch (algo)
595     {
596     case AEAD_ALGO_NONE:
597       break;
598     case AEAD_ALGO_EAX:
599     case AEAD_ALGO_OCB:
600       return 0;
601     }
602
603   return gpg_error (GPG_ERR_INV_CIPHER_MODE);
604 }
605
606
607 /* Map the OpenPGP AEAD algorithm with ID ALGO to a string
608  * representation of the algorithm name.  For unknown algorithm IDs
609  * this function returns "?".  */
610 const char *
611 openpgp_aead_algo_name (aead_algo_t algo)
612 {
613   switch (algo)
614     {
615     case AEAD_ALGO_NONE:  break;
616     case AEAD_ALGO_EAX:   return "EAX";
617     case AEAD_ALGO_OCB:   return "OCB";
618     }
619
620   return "?";
621 }
622
623
624 /* Return information for the AEAD algorithm ALGO.  The corresponding
625  * Libgcrypt ciphermode is stored at R_MODE and the required number of
626  * octets for the nonce at R_NONCELEN.  On error and error code is
627  * returned.  Note that the taglen is always 128 bits.  */
628 gpg_error_t
629 openpgp_aead_algo_info (aead_algo_t algo, enum gcry_cipher_modes *r_mode,
630                         unsigned int *r_noncelen)
631 {
632   switch (algo)
633     {
634     case AEAD_ALGO_OCB:
635       *r_mode = GCRY_CIPHER_MODE_OCB;
636       *r_noncelen = 15;
637       break;
638
639     case AEAD_ALGO_EAX:
640       *r_mode = MY_GCRY_CIPHER_MODE_EAX;
641       *r_noncelen = 16;
642       break;
643
644     default:
645       log_error ("unsupported AEAD algo %d\n", algo);
646       return gpg_error (GPG_ERR_INV_CIPHER_MODE);
647     }
648   return 0;
649 }
650
651
652 /* Return 0 if ALGO is a supported OpenPGP public key algorithm.  */
653 int
654 openpgp_pk_test_algo (pubkey_algo_t algo)
655 {
656   return openpgp_pk_test_algo2 (algo, 0);
657 }
658
659
660 /* Return 0 if ALGO is a supported OpenPGP public key algorithm and
661    allows the usage USE.  */
662 int
663 openpgp_pk_test_algo2 (pubkey_algo_t algo, unsigned int use)
664 {
665   enum gcry_pk_algos ga = 0;
666   size_t use_buf = use;
667
668   switch (algo)
669     {
670 #ifdef GPG_USE_RSA
671     case PUBKEY_ALGO_RSA:       ga = GCRY_PK_RSA;   break;
672     case PUBKEY_ALGO_RSA_E:     ga = GCRY_PK_RSA_E; break;
673     case PUBKEY_ALGO_RSA_S:     ga = GCRY_PK_RSA_S; break;
674 #else
675     case PUBKEY_ALGO_RSA:       break;
676     case PUBKEY_ALGO_RSA_E:     break;
677     case PUBKEY_ALGO_RSA_S:     break;
678 #endif
679
680     case PUBKEY_ALGO_ELGAMAL_E: ga = GCRY_PK_ELG;   break;
681     case PUBKEY_ALGO_DSA:       ga = GCRY_PK_DSA;   break;
682
683 #ifdef GPG_USE_ECDH
684     case PUBKEY_ALGO_ECDH:      ga = GCRY_PK_ECC;   break;
685 #else
686     case PUBKEY_ALGO_ECDH:      break;
687 #endif
688
689 #ifdef GPG_USE_ECDSA
690     case PUBKEY_ALGO_ECDSA:     ga = GCRY_PK_ECC;   break;
691 #else
692     case PUBKEY_ALGO_ECDSA:     break;
693 #endif
694
695 #ifdef GPG_USE_EDDSA
696     case PUBKEY_ALGO_EDDSA:     ga = GCRY_PK_ECC;   break;
697 #else
698     case PUBKEY_ALGO_EDDSA:     break;
699 #endif
700
701     case PUBKEY_ALGO_ELGAMAL:
702       /* Dont't allow type 20 keys unless in rfc2440 mode.  */
703       if (RFC2440)
704         ga = GCRY_PK_ELG;
705       break;
706
707     default:
708       break;
709     }
710   if (!ga)
711     return gpg_error (GPG_ERR_PUBKEY_ALGO);
712
713   /* Now check whether Libgcrypt has support for the algorithm.  */
714   return gcry_pk_algo_info (ga, GCRYCTL_TEST_ALGO, NULL, &use_buf);
715 }
716
717
718 int
719 openpgp_pk_algo_usage ( int algo )
720 {
721     int use = 0;
722
723     /* They are hardwired in gpg 1.0. */
724     switch ( algo ) {
725       case PUBKEY_ALGO_RSA:
726           use = (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG
727                  | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH);
728           break;
729       case PUBKEY_ALGO_RSA_E:
730       case PUBKEY_ALGO_ECDH:
731           use = PUBKEY_USAGE_ENC;
732           break;
733       case PUBKEY_ALGO_RSA_S:
734           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG;
735           break;
736       case PUBKEY_ALGO_ELGAMAL:
737           if (RFC2440)
738              use = PUBKEY_USAGE_ENC;
739           break;
740       case PUBKEY_ALGO_ELGAMAL_E:
741           use = PUBKEY_USAGE_ENC;
742           break;
743       case PUBKEY_ALGO_DSA:
744           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
745           break;
746       case PUBKEY_ALGO_ECDSA:
747       case PUBKEY_ALGO_EDDSA:
748           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
749       default:
750           break;
751     }
752     return use;
753 }
754
755 /* Map the OpenPGP pubkey algorithm whose ID is contained in ALGO to a
756    string representation of the algorithm name.  For unknown algorithm
757    IDs this function returns "?".  */
758 const char *
759 openpgp_pk_algo_name (pubkey_algo_t algo)
760 {
761   switch (algo)
762     {
763     case PUBKEY_ALGO_RSA:
764     case PUBKEY_ALGO_RSA_E:
765     case PUBKEY_ALGO_RSA_S:     return "RSA";
766     case PUBKEY_ALGO_ELGAMAL:
767     case PUBKEY_ALGO_ELGAMAL_E: return "ELG";
768     case PUBKEY_ALGO_DSA:       return "DSA";
769     case PUBKEY_ALGO_ECDH:      return "ECDH";
770     case PUBKEY_ALGO_ECDSA:     return "ECDSA";
771     case PUBKEY_ALGO_EDDSA:     return "EDDSA";
772     default: return "?";
773     }
774 }
775
776
777 /* Explicit mapping of OpenPGP digest algos to Libgcrypt.  */
778 /* FIXME: We do not yes use it everywhere.  */
779 enum gcry_md_algos
780 map_md_openpgp_to_gcry (digest_algo_t algo)
781 {
782   switch (algo)
783     {
784 #ifdef GPG_USE_MD5
785     case DIGEST_ALGO_MD5:    return GCRY_MD_MD5;
786 #else
787     case DIGEST_ALGO_MD5:    return 0;
788 #endif
789
790     case DIGEST_ALGO_SHA1:   return GCRY_MD_SHA1;
791
792 #ifdef GPG_USE_RMD160
793     case DIGEST_ALGO_RMD160: return GCRY_MD_RMD160;
794 #else
795     case DIGEST_ALGO_RMD160: return 0;
796 #endif
797
798 #ifdef GPG_USE_SHA224
799     case DIGEST_ALGO_SHA224: return GCRY_MD_SHA224;
800 #else
801     case DIGEST_ALGO_SHA224: return 0;
802 #endif
803
804     case DIGEST_ALGO_SHA256: return GCRY_MD_SHA256;
805
806 #ifdef GPG_USE_SHA384
807     case DIGEST_ALGO_SHA384: return GCRY_MD_SHA384;
808 #else
809     case DIGEST_ALGO_SHA384: return 0;
810 #endif
811
812 #ifdef GPG_USE_SHA512
813     case DIGEST_ALGO_SHA512: return GCRY_MD_SHA512;
814 #else
815     case DIGEST_ALGO_SHA512: return 0;
816 #endif
817     default: return 0;
818     }
819 }
820
821
822 /* Return 0 if ALGO is suitable and implemented OpenPGP hash
823    algorithm.  */
824 int
825 openpgp_md_test_algo (digest_algo_t algo)
826 {
827   enum gcry_md_algos ga;
828
829   ga = map_md_openpgp_to_gcry (algo);
830   if (!ga)
831     return gpg_error (GPG_ERR_DIGEST_ALGO);
832
833   return gcry_md_test_algo (ga);
834 }
835
836
837 /* Map the OpenPGP digest algorithm whose ID is contained in ALGO to a
838    string representation of the algorithm name.  For unknown algorithm
839    IDs this function returns "?".  */
840 const char *
841 openpgp_md_algo_name (int algo)
842 {
843   switch (algo)
844     {
845     case DIGEST_ALGO_MD5:    return "MD5";
846     case DIGEST_ALGO_SHA1:   return "SHA1";
847     case DIGEST_ALGO_RMD160: return "RIPEMD160";
848     case DIGEST_ALGO_SHA256: return "SHA256";
849     case DIGEST_ALGO_SHA384: return "SHA384";
850     case DIGEST_ALGO_SHA512: return "SHA512";
851     case DIGEST_ALGO_SHA224: return "SHA224";
852     }
853   return "?";
854 }
855
856
857 static unsigned long
858 get_signature_count (PKT_public_key *pk)
859 {
860 #ifdef ENABLE_CARD_SUPPORT
861   struct agent_card_info_s info;
862
863   (void)pk;
864   if (!agent_scd_getattr ("SIG-COUNTER",&info))
865     return info.sig_counter;
866   else
867     return 0;
868 #else
869   (void)pk;
870   return 0;
871 #endif
872 }
873
874 /* Expand %-strings.  Returns a string which must be xfreed.  Returns
875    NULL if the string cannot be expanded (too large). */
876 char *
877 pct_expando(const char *string,struct expando_args *args)
878 {
879   const char *ch=string;
880   int idx=0,maxlen=0,done=0;
881   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
882   char *ret=NULL;
883
884   if(args->pk)
885     keyid_from_pk(args->pk,pk_keyid);
886
887   if(args->pksk)
888     keyid_from_pk (args->pksk, sk_keyid);
889
890   /* This is used so that %k works in photoid command strings in
891      --list-secret-keys (which of course has a sk, but no pk). */
892   if(!args->pk && args->pksk)
893     keyid_from_pk (args->pksk, pk_keyid);
894
895   while(*ch!='\0')
896     {
897       if(!done)
898         {
899           /* 8192 is way bigger than we'll need here */
900           if(maxlen>=8192)
901             goto fail;
902
903           maxlen+=1024;
904           ret=xrealloc(ret,maxlen);
905         }
906
907       done=0;
908
909       if(*ch=='%')
910         {
911           switch(*(ch+1))
912             {
913             case 's': /* short key id */
914               if(idx+8<maxlen)
915                 {
916                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
917                   idx+=8;
918                   done=1;
919                 }
920               break;
921
922             case 'S': /* long key id */
923               if(idx+16<maxlen)
924                 {
925                   sprintf(&ret[idx],"%08lX%08lX",
926                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
927                   idx+=16;
928                   done=1;
929                 }
930               break;
931
932             case 'k': /* short key id */
933               if(idx+8<maxlen)
934                 {
935                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
936                   idx+=8;
937                   done=1;
938                 }
939               break;
940
941             case 'K': /* long key id */
942               if(idx+16<maxlen)
943                 {
944                   sprintf(&ret[idx],"%08lX%08lX",
945                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
946                   idx+=16;
947                   done=1;
948                 }
949               break;
950
951             case 'U': /* z-base-32 encoded user id hash. */
952               if (args->namehash)
953                 {
954                   char *tmp = zb32_encode (args->namehash, 8*20);
955                   if (tmp)
956                     {
957                       if (idx + strlen (tmp) < maxlen)
958                         {
959                           strcpy (ret+idx, tmp);
960                           idx += strlen (tmp);
961                         }
962                       xfree (tmp);
963                       done = 1;
964                     }
965                 }
966               break;
967
968             case 'c': /* signature count from card, if any. */
969               if(idx+10<maxlen)
970                 {
971                   sprintf (&ret[idx],"%lu", get_signature_count (args->pksk));
972                   idx+=strlen(&ret[idx]);
973                   done=1;
974                 }
975               break;
976
977             case 'f': /* Fingerprint of key being signed */
978             case 'p': /* Fingerprint of the primary key making the signature. */
979             case 'g': /* Fingerprint of the key making the signature.  */
980               {
981                 byte array[MAX_FINGERPRINT_LEN];
982                 size_t len;
983                 int i;
984
985                 if ((*(ch+1))=='f' && args->pk)
986                   fingerprint_from_pk (args->pk, array, &len);
987                 else if ((*(ch+1))=='p' && args->pksk)
988                   {
989                     if(args->pksk->flags.primary)
990                       fingerprint_from_pk (args->pksk, array, &len);
991                     else if (args->pksk->main_keyid[0]
992                              || args->pksk->main_keyid[1])
993                       {
994                         /* Not the primary key: Find the fingerprint
995                            of the primary key.  */
996                         PKT_public_key *pk=
997                           xmalloc_clear(sizeof(PKT_public_key));
998
999                         if (!get_pubkey_fast (pk,args->pksk->main_keyid))
1000                           fingerprint_from_pk (pk, array, &len);
1001                         else
1002                           memset (array, 0, (len=MAX_FINGERPRINT_LEN));
1003                         free_public_key (pk);
1004                       }
1005                     else /* Oops: info about the primary key missing.  */
1006                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
1007                   }
1008                 else if((*(ch+1))=='g' && args->pksk)
1009                   fingerprint_from_pk (args->pksk, array, &len);
1010                 else
1011                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
1012
1013                 if(idx+(len*2)<maxlen)
1014                   {
1015                     for(i=0;i<len;i++)
1016                       {
1017                         sprintf(&ret[idx],"%02X",array[i]);
1018                         idx+=2;
1019                       }
1020                     done=1;
1021                   }
1022               }
1023               break;
1024
1025             case 'v': /* validity letters */
1026               if(args->validity_info && idx+1<maxlen)
1027                 {
1028                   ret[idx++]=args->validity_info;
1029                   ret[idx]='\0';
1030                   done=1;
1031                 }
1032               break;
1033
1034               /* The text string types */
1035             case 't':
1036             case 'T':
1037             case 'V':
1038               {
1039                 const char *str=NULL;
1040
1041                 switch(*(ch+1))
1042                   {
1043                   case 't': /* e.g. "jpg" */
1044                     str=image_type_to_string(args->imagetype,0);
1045                     break;
1046
1047                   case 'T': /* e.g. "image/jpeg" */
1048                     str=image_type_to_string(args->imagetype,2);
1049                     break;
1050
1051                   case 'V': /* e.g. "full", "expired", etc. */
1052                     str=args->validity_string;
1053                     break;
1054                   }
1055
1056                 if(str && idx+strlen(str)<maxlen)
1057                   {
1058                     strcpy(&ret[idx],str);
1059                     idx+=strlen(str);
1060                     done=1;
1061                   }
1062               }
1063               break;
1064
1065             case '%':
1066               if(idx+1<maxlen)
1067                 {
1068                   ret[idx++]='%';
1069                   ret[idx]='\0';
1070                   done=1;
1071                 }
1072               break;
1073
1074               /* Any unknown %-keys (like %i, %o, %I, and %O) are
1075                  passed through for later expansion.  Note this also
1076                  handles the case where the last character in the
1077                  string is a '%' - the terminating \0 will end up here
1078                  and properly terminate the string. */
1079             default:
1080               if(idx+2<maxlen)
1081                 {
1082                   ret[idx++]='%';
1083                   ret[idx++]=*(ch+1);
1084                   ret[idx]='\0';
1085                   done=1;
1086                 }
1087               break;
1088               }
1089
1090           if(done)
1091             ch++;
1092         }
1093       else
1094         {
1095           if(idx+1<maxlen)
1096             {
1097               ret[idx++]=*ch;
1098               ret[idx]='\0';
1099               done=1;
1100             }
1101         }
1102
1103       if(done)
1104         ch++;
1105     }
1106
1107   return ret;
1108
1109  fail:
1110   xfree(ret);
1111   return NULL;
1112 }
1113
1114 void
1115 deprecated_warning(const char *configname,unsigned int configlineno,
1116                    const char *option,const char *repl1,const char *repl2)
1117 {
1118   if(configname)
1119     {
1120       if(strncmp("--",option,2)==0)
1121         option+=2;
1122
1123       if(strncmp("--",repl1,2)==0)
1124         repl1+=2;
1125
1126       log_info(_("%s:%d: deprecated option \"%s\"\n"),
1127                configname,configlineno,option);
1128     }
1129   else
1130     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
1131
1132   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
1133 }
1134
1135
1136 void
1137 deprecated_command (const char *name)
1138 {
1139   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
1140            name);
1141 }
1142
1143
1144 void
1145 obsolete_scdaemon_option (const char *configname, unsigned int configlineno,
1146                           const char *name)
1147 {
1148   if (configname)
1149     log_info (_("%s:%u: \"%s\" is obsolete in this file"
1150                 " - it only has effect in %s\n"),
1151               configname, configlineno, name, SCDAEMON_NAME EXTSEP_S "conf");
1152   else
1153     log_info (_("WARNING: \"%s%s\" is an obsolete option"
1154                 " - it has no effect except on %s\n"),
1155               "--", name, SCDAEMON_NAME);
1156 }
1157
1158
1159 /*
1160  * Wrapper around gcry_cipher_map_name to provide a fallback using the
1161  * "Sn" syntax as used by the preference strings.
1162  */
1163 int
1164 string_to_cipher_algo (const char *string)
1165 {
1166   int val;
1167
1168   val = map_cipher_gcry_to_openpgp (gcry_cipher_map_name (string));
1169   if (!val && string && (string[0]=='S' || string[0]=='s'))
1170     {
1171       char *endptr;
1172
1173       string++;
1174       val = strtol (string, &endptr, 10);
1175       if (!*string || *endptr || openpgp_cipher_test_algo (val))
1176         val = 0;
1177     }
1178
1179   return val;
1180 }
1181
1182
1183 /*
1184  * Map an AEAD mode string to a an AEAD algorithm number as defined by
1185  * rrc4880bis.  Also support the "An" syntax as used by the preference
1186  * strings.
1187  */
1188 aead_algo_t
1189 string_to_aead_algo (const char *string)
1190 {
1191   int result;
1192
1193   if (!string)
1194     result = 0;
1195   if (!ascii_strcasecmp (string, "EAX"))
1196     result = 1;
1197   else if (!ascii_strcasecmp (string, "OCB"))
1198     result = 2;
1199   else if ((string[0]=='A' || string[0]=='a'))
1200     {
1201       char *endptr;
1202
1203       string++;
1204       result = strtol (string, &endptr, 10);
1205       if (!*string || *endptr || result < 1 || result > 2)
1206         result = 0;
1207     }
1208   else
1209     result = 0;
1210
1211   return result;
1212 }
1213
1214
1215 /*
1216  * Wrapper around gcry_md_map_name to provide a fallback using the
1217  * "Hn" syntax as used by the preference strings.
1218  */
1219 int
1220 string_to_digest_algo (const char *string)
1221 {
1222   int val;
1223
1224   /* FIXME: We should make use of our wrapper function and not assume
1225      that there is a 1 to 1 mapping between OpenPGP and Libgcrypt.  */
1226   val = gcry_md_map_name (string);
1227   if (!val && string && (string[0]=='H' || string[0]=='h'))
1228     {
1229       char *endptr;
1230
1231       string++;
1232       val = strtol (string, &endptr, 10);
1233       if (!*string || *endptr || openpgp_md_test_algo (val))
1234         val = 0;
1235     }
1236
1237   return val;
1238 }
1239
1240
1241
1242 const char *
1243 compress_algo_to_string(int algo)
1244 {
1245   const char *s=NULL;
1246
1247   switch(algo)
1248     {
1249     case COMPRESS_ALGO_NONE:
1250       s=_("Uncompressed");
1251       break;
1252
1253     case COMPRESS_ALGO_ZIP:
1254       s="ZIP";
1255       break;
1256
1257     case COMPRESS_ALGO_ZLIB:
1258       s="ZLIB";
1259       break;
1260
1261 #ifdef HAVE_BZIP2
1262     case COMPRESS_ALGO_BZIP2:
1263       s="BZIP2";
1264       break;
1265 #endif
1266     }
1267
1268   return s;
1269 }
1270
1271 int
1272 string_to_compress_algo(const char *string)
1273 {
1274   /* TRANSLATORS: See doc/TRANSLATE about this string. */
1275   if(match_multistr(_("uncompressed|none"),string))
1276     return 0;
1277   else if(ascii_strcasecmp(string,"uncompressed")==0)
1278     return 0;
1279   else if(ascii_strcasecmp(string,"none")==0)
1280     return 0;
1281   else if(ascii_strcasecmp(string,"zip")==0)
1282     return 1;
1283   else if(ascii_strcasecmp(string,"zlib")==0)
1284     return 2;
1285 #ifdef HAVE_BZIP2
1286   else if(ascii_strcasecmp(string,"bzip2")==0)
1287     return 3;
1288 #endif
1289   else if(ascii_strcasecmp(string,"z0")==0)
1290     return 0;
1291   else if(ascii_strcasecmp(string,"z1")==0)
1292     return 1;
1293   else if(ascii_strcasecmp(string,"z2")==0)
1294     return 2;
1295 #ifdef HAVE_BZIP2
1296   else if(ascii_strcasecmp(string,"z3")==0)
1297     return 3;
1298 #endif
1299   else
1300     return -1;
1301 }
1302
1303 int
1304 check_compress_algo(int algo)
1305 {
1306   switch (algo)
1307     {
1308     case 0: return 0;
1309 #ifdef HAVE_ZIP
1310     case 1:
1311     case 2: return 0;
1312 #endif
1313 #ifdef HAVE_BZIP2
1314     case 3: return 0;
1315 #endif
1316     default: return GPG_ERR_COMPR_ALGO;
1317     }
1318 }
1319
1320 int
1321 default_cipher_algo(void)
1322 {
1323   if(opt.def_cipher_algo)
1324     return opt.def_cipher_algo;
1325   else if(opt.personal_cipher_prefs)
1326     return opt.personal_cipher_prefs[0].value;
1327   else
1328     return opt.s2k_cipher_algo;
1329 }
1330
1331
1332 aead_algo_t
1333 default_aead_algo(void)
1334 {
1335   if(opt.def_aead_algo)
1336     return opt.def_aead_algo;
1337   else if(opt.personal_aead_prefs)
1338     return opt.personal_aead_prefs[0].value;
1339   else
1340     return DEFAULT_AEAD_ALGO;
1341 }
1342
1343 /* There is no default_digest_algo function, but see
1344    sign.c:hash_for() */
1345
1346 int
1347 default_compress_algo(void)
1348 {
1349   if(opt.compress_algo!=-1)
1350     return opt.compress_algo;
1351   else if(opt.personal_compress_prefs)
1352     return opt.personal_compress_prefs[0].value;
1353   else
1354     return DEFAULT_COMPRESS_ALGO;
1355 }
1356
1357
1358 void
1359 compliance_failure(void)
1360 {
1361   char *ver="???";
1362
1363   switch(opt.compliance)
1364     {
1365     case CO_GNUPG:
1366       ver="GnuPG";
1367       break;
1368
1369     case CO_RFC4880:
1370       ver="OpenPGP";
1371       break;
1372
1373     case CO_RFC2440:
1374       ver="OpenPGP (older)";
1375       break;
1376
1377     case CO_PGP6:
1378       ver="PGP 6.x";
1379       break;
1380
1381     case CO_PGP7:
1382       ver="PGP 7.x";
1383       break;
1384
1385     case CO_PGP8:
1386       ver="PGP 8.x";
1387       break;
1388
1389     case CO_DE_VS:
1390       ver="DE-VS applications";
1391       break;
1392     }
1393
1394   log_info(_("this message may not be usable by %s\n"),ver);
1395   opt.compliance=CO_GNUPG;
1396 }
1397
1398 /* Break a string into successive option pieces.  Accepts single word
1399    options and key=value argument options. */
1400 char *
1401 optsep(char **stringp)
1402 {
1403   char *tok,*end;
1404
1405   tok=*stringp;
1406   if(tok)
1407     {
1408       end=strpbrk(tok," ,=");
1409       if(end)
1410         {
1411           int sawequals=0;
1412           char *ptr=end;
1413
1414           /* what we need to do now is scan along starting with *end,
1415              If the next character we see (ignoring spaces) is an =
1416              sign, then there is an argument. */
1417
1418           while(*ptr)
1419             {
1420               if(*ptr=='=')
1421                 sawequals=1;
1422               else if(*ptr!=' ')
1423                 break;
1424               ptr++;
1425             }
1426
1427           /* There is an argument, so grab that too.  At this point,
1428              ptr points to the first character of the argument. */
1429           if(sawequals)
1430             {
1431               /* Is it a quoted argument? */
1432               if(*ptr=='"')
1433                 {
1434                   ptr++;
1435                   end=strchr(ptr,'"');
1436                   if(end)
1437                     end++;
1438                 }
1439               else
1440                 end=strpbrk(ptr," ,");
1441             }
1442
1443           if(end && *end)
1444             {
1445               *end='\0';
1446               *stringp=end+1;
1447             }
1448           else
1449             *stringp=NULL;
1450         }
1451       else
1452         *stringp=NULL;
1453     }
1454
1455   return tok;
1456 }
1457
1458 /* Breaks an option value into key and value.  Returns NULL if there
1459    is no value.  Note that "string" is modified to remove the =value
1460    part. */
1461 char *
1462 argsplit(char *string)
1463 {
1464   char *equals,*arg=NULL;
1465
1466   equals=strchr(string,'=');
1467   if(equals)
1468     {
1469       char *quote,*space;
1470
1471       *equals='\0';
1472       arg=equals+1;
1473
1474       /* Quoted arg? */
1475       quote=strchr(arg,'"');
1476       if(quote)
1477         {
1478           arg=quote+1;
1479
1480           quote=strchr(arg,'"');
1481           if(quote)
1482             *quote='\0';
1483         }
1484       else
1485         {
1486           size_t spaces;
1487
1488           /* Trim leading spaces off of the arg */
1489           spaces=strspn(arg," ");
1490           arg+=spaces;
1491         }
1492
1493       /* Trim tailing spaces off of the tag */
1494       space=strchr(string,' ');
1495       if(space)
1496         *space='\0';
1497     }
1498
1499   return arg;
1500 }
1501
1502 /* Return the length of the initial token, leaving off any
1503    argument. */
1504 static size_t
1505 optlen(const char *s)
1506 {
1507   char *end=strpbrk(s," =");
1508
1509   if(end)
1510     return end-s;
1511   else
1512     return strlen(s);
1513 }
1514
1515 int
1516 parse_options(char *str,unsigned int *options,
1517               struct parse_options *opts,int noisy)
1518 {
1519   char *tok;
1520
1521   if (str && !strcmp (str, "help"))
1522     {
1523       int i,maxlen=0;
1524
1525       /* Figure out the longest option name so we can line these up
1526          neatly. */
1527       for(i=0;opts[i].name;i++)
1528         if(opts[i].help && maxlen<strlen(opts[i].name))
1529           maxlen=strlen(opts[i].name);
1530
1531       for(i=0;opts[i].name;i++)
1532         if(opts[i].help)
1533           es_printf("%s%*s%s\n",opts[i].name,
1534                     maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1535
1536       g10_exit(0);
1537     }
1538
1539   while((tok=optsep(&str)))
1540     {
1541       int i,rev=0;
1542       char *otok=tok;
1543
1544       if(tok[0]=='\0')
1545         continue;
1546
1547       if(ascii_strncasecmp("no-",tok,3)==0)
1548         {
1549           rev=1;
1550           tok+=3;
1551         }
1552
1553       for(i=0;opts[i].name;i++)
1554         {
1555           size_t toklen=optlen(tok);
1556
1557           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1558             {
1559               /* We have a match, but it might be incomplete */
1560               if(toklen!=strlen(opts[i].name))
1561                 {
1562                   int j;
1563
1564                   for(j=i+1;opts[j].name;j++)
1565                     {
1566                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1567                         {
1568                           if(noisy)
1569                             log_info(_("ambiguous option '%s'\n"),otok);
1570                           return 0;
1571                         }
1572                     }
1573                 }
1574
1575               if(rev)
1576                 {
1577                   *options&=~opts[i].bit;
1578                   if(opts[i].value)
1579                     *opts[i].value=NULL;
1580                 }
1581               else
1582                 {
1583                   *options|=opts[i].bit;
1584                   if(opts[i].value)
1585                     *opts[i].value=argsplit(tok);
1586                 }
1587               break;
1588             }
1589         }
1590
1591       if(!opts[i].name)
1592         {
1593           if(noisy)
1594             log_info(_("unknown option '%s'\n"),otok);
1595           return 0;
1596         }
1597     }
1598
1599   return 1;
1600 }
1601
1602
1603 /* Similar to access(2), but uses PATH to find the file. */
1604 int
1605 path_access(const char *file,int mode)
1606 {
1607   char *envpath;
1608   int ret=-1;
1609
1610   envpath=getenv("PATH");
1611
1612   if(!envpath
1613 #ifdef HAVE_DRIVE_LETTERS
1614      || (((file[0]>='A' && file[0]<='Z')
1615           || (file[0]>='a' && file[0]<='z'))
1616          && file[1]==':')
1617 #else
1618      || file[0]=='/'
1619 #endif
1620      )
1621     return access(file,mode);
1622   else
1623     {
1624       /* At least as large as, but most often larger than we need. */
1625       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1626       char *split,*item,*path=xstrdup(envpath);
1627
1628       split=path;
1629
1630       while((item=strsep(&split,PATHSEP_S)))
1631         {
1632           strcpy(buffer,item);
1633           strcat(buffer,"/");
1634           strcat(buffer,file);
1635           ret=access(buffer,mode);
1636           if(ret==0)
1637             break;
1638         }
1639
1640       xfree(path);
1641       xfree(buffer);
1642     }
1643
1644   return ret;
1645 }
1646
1647
1648 \f
1649 /* Return the number of public key parameters as used by OpenPGP.  */
1650 int
1651 pubkey_get_npkey (pubkey_algo_t algo)
1652 {
1653   switch (algo)
1654     {
1655     case PUBKEY_ALGO_RSA:
1656     case PUBKEY_ALGO_RSA_E:
1657     case PUBKEY_ALGO_RSA_S:     return 2;
1658     case PUBKEY_ALGO_ELGAMAL_E: return 3;
1659     case PUBKEY_ALGO_DSA:       return 4;
1660     case PUBKEY_ALGO_ECDH:      return 3;
1661     case PUBKEY_ALGO_ECDSA:     return 2;
1662     case PUBKEY_ALGO_ELGAMAL:   return 3;
1663     case PUBKEY_ALGO_EDDSA:     return 2;
1664     default: return 0;
1665     }
1666 }
1667
1668
1669 /* Return the number of secret key parameters as used by OpenPGP.  */
1670 int
1671 pubkey_get_nskey (pubkey_algo_t algo)
1672 {
1673   switch (algo)
1674     {
1675     case PUBKEY_ALGO_RSA:
1676     case PUBKEY_ALGO_RSA_E:
1677     case PUBKEY_ALGO_RSA_S:     return 6;
1678     case PUBKEY_ALGO_ELGAMAL_E: return 4;
1679     case PUBKEY_ALGO_DSA:       return 5;
1680     case PUBKEY_ALGO_ECDH:      return 4;
1681     case PUBKEY_ALGO_ECDSA:     return 3;
1682     case PUBKEY_ALGO_ELGAMAL:   return 4;
1683     case PUBKEY_ALGO_EDDSA:     return 3;
1684     default: return 0;
1685     }
1686 }
1687
1688 /* Temporary helper. */
1689 int
1690 pubkey_get_nsig (pubkey_algo_t algo)
1691 {
1692   switch (algo)
1693     {
1694     case PUBKEY_ALGO_RSA:
1695     case PUBKEY_ALGO_RSA_E:
1696     case PUBKEY_ALGO_RSA_S:     return 1;
1697     case PUBKEY_ALGO_ELGAMAL_E: return 0;
1698     case PUBKEY_ALGO_DSA:       return 2;
1699     case PUBKEY_ALGO_ECDH:      return 0;
1700     case PUBKEY_ALGO_ECDSA:     return 2;
1701     case PUBKEY_ALGO_ELGAMAL:   return 2;
1702     case PUBKEY_ALGO_EDDSA:     return 2;
1703     default: return 0;
1704     }
1705 }
1706
1707
1708 /* Temporary helper. */
1709 int
1710 pubkey_get_nenc (pubkey_algo_t algo)
1711 {
1712   switch (algo)
1713     {
1714     case PUBKEY_ALGO_RSA:
1715     case PUBKEY_ALGO_RSA_E:
1716     case PUBKEY_ALGO_RSA_S:     return 1;
1717     case PUBKEY_ALGO_ELGAMAL_E: return 2;
1718     case PUBKEY_ALGO_DSA:       return 0;
1719     case PUBKEY_ALGO_ECDH:      return 2;
1720     case PUBKEY_ALGO_ECDSA:     return 0;
1721     case PUBKEY_ALGO_ELGAMAL:   return 2;
1722     case PUBKEY_ALGO_EDDSA:     return 0;
1723     default: return 0;
1724     }
1725 }
1726
1727
1728 /* Temporary helper. */
1729 unsigned int
1730 pubkey_nbits( int algo, gcry_mpi_t *key )
1731 {
1732   int rc, nbits;
1733   gcry_sexp_t sexp;
1734
1735   if (algo == PUBKEY_ALGO_DSA
1736       && key[0] && key[1] && key[2] && key[3])
1737     {
1738       rc = gcry_sexp_build (&sexp, NULL,
1739                             "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1740                             key[0], key[1], key[2], key[3] );
1741     }
1742   else if ((algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E)
1743            && key[0] && key[1] && key[2])
1744     {
1745       rc = gcry_sexp_build (&sexp, NULL,
1746                             "(public-key(elg(p%m)(g%m)(y%m)))",
1747                             key[0], key[1], key[2] );
1748     }
1749   else if (is_RSA (algo)
1750            && key[0] && key[1])
1751     {
1752       rc = gcry_sexp_build (&sexp, NULL,
1753                             "(public-key(rsa(n%m)(e%m)))",
1754                             key[0], key[1] );
1755     }
1756   else if ((algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_ECDH
1757             || algo == PUBKEY_ALGO_EDDSA)
1758            && key[0] && key[1])
1759     {
1760       char *curve = openpgp_oid_to_str (key[0]);
1761       if (!curve)
1762         rc = gpg_error_from_syserror ();
1763       else
1764         {
1765           rc = gcry_sexp_build (&sexp, NULL,
1766                                 "(public-key(ecc(curve%s)(q%m)))",
1767                                 curve, key[1]);
1768           xfree (curve);
1769         }
1770     }
1771   else
1772     return 0;
1773
1774   if (rc)
1775     BUG ();
1776
1777   nbits = gcry_pk_get_nbits (sexp);
1778   gcry_sexp_release (sexp);
1779   return nbits;
1780 }
1781
1782
1783
1784 int
1785 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1786 {
1787   int n = 0;
1788   size_t nwritten;
1789
1790   if (!a)
1791     return es_fprintf (fp, "[MPI_NULL]");
1792   if (!mode)
1793     {
1794       unsigned int n1;
1795       n1 = gcry_mpi_get_nbits(a);
1796       n += es_fprintf (fp, "[%u bits]", n1);
1797     }
1798   else if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
1799     {
1800       unsigned int nbits;
1801       unsigned char *p = gcry_mpi_get_opaque (a, &nbits);
1802       if (!p)
1803         n += es_fprintf (fp, "[invalid opaque value]");
1804       else
1805         {
1806           if (!es_write_hexstring (fp, p, (nbits + 7)/8, 0, &nwritten))
1807             n += nwritten;
1808         }
1809     }
1810   else
1811     {
1812       unsigned char *buffer;
1813       size_t buflen;
1814
1815       if (gcry_mpi_aprint (GCRYMPI_FMT_USG, &buffer, &buflen, a))
1816         BUG ();
1817       if (!es_write_hexstring (fp, buffer, buflen, 0, &nwritten))
1818         n += nwritten;
1819       gcry_free (buffer);
1820     }
1821   return n;
1822 }
1823
1824
1825 /* pkey[1] or skey[1] is Q for ECDSA, which is an uncompressed point,
1826    i.e.  04 <x> <y> */
1827 unsigned int
1828 ecdsa_qbits_from_Q (unsigned int qbits)
1829 {
1830   if ((qbits%8) > 3)
1831     {
1832       log_error (_("ECDSA public key is expected to be in SEC encoding "
1833                    "multiple of 8 bits\n"));
1834       return 0;
1835     }
1836   qbits -= qbits%8;
1837   qbits /= 2;
1838   return qbits;
1839 }
1840
1841
1842 /* Ignore signatures and certifications made over certain digest
1843  * algorithms by default, MD5 is considered weak.  This allows users
1844  * to deprecate support for other algorithms as well.
1845  */
1846 void
1847 additional_weak_digest (const char* digestname)
1848 {
1849   struct weakhash *weak = NULL;
1850   const enum gcry_md_algos algo = string_to_digest_algo(digestname);
1851
1852   if (algo == GCRY_MD_NONE)
1853     {
1854       log_error (_("unknown weak digest '%s'\n"), digestname);
1855       return;
1856     }
1857
1858   /* Check to ensure it's not already present.  */
1859   for (weak = opt.weak_digests; weak; weak = weak->next)
1860     if (algo == weak->algo)
1861       return;
1862
1863   /* Add it to the head of the list.  */
1864   weak = xmalloc(sizeof(*weak));
1865   weak->algo = algo;
1866   weak->rejection_shown = 0;
1867   weak->next = opt.weak_digests;
1868   opt.weak_digests = weak;
1869 }