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