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