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