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