Editorial changes and allow building with old libgcrypts.
[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 int
345 map_cipher_openpgp_to_gcry (int algo)
346 {
347   switch (algo)
348     {
349     case CIPHER_ALGO_CAMELLIA128: return 310; 
350     case CIPHER_ALGO_CAMELLIA192: return 311; 
351     case CIPHER_ALGO_CAMELLIA256: return 312; 
352     default: return algo;
353     }
354 }
355
356 /* The inverse fucntion of above.  */
357 static int
358 map_cipher_gcry_to_openpgp (int algo)
359 {
360   switch (algo)
361     {
362     case 310: return CIPHER_ALGO_CAMELLIA128;
363     case 311: return CIPHER_ALGO_CAMELLIA192;
364     case 312: return CIPHER_ALGO_CAMELLIA256;
365     default: return algo;
366     }
367 }
368
369 /* Map OpenPGP public key algorithm numbers to those used by
370    Libgcrypt.  */
371 int
372 map_pk_openpgp_to_gcry (int algo)
373 {
374   switch (algo)
375     {
376     case PUBKEY_ALGO_ECDSA: return GCRY_PK_ECDSA;
377     case PUBKEY_ALGO_ECDH:  return GCRY_PK_ECDH;
378     default: return algo;
379     }
380 }
381
382
383 /* Return the block length of an OpenPGP cipher algorithm.  */
384 int 
385 openpgp_cipher_blocklen (int algo)
386 {
387   /* We use the numbers from OpenPGP to be sure that we get the right
388      block length.  This is so that the packet parsing code works even
389      for unknown algorithms (for which we assume 8 due to tradition).
390
391      NOTE: If you change the the returned blocklen above 16, check
392      the callers because they may use a fixed size buffer of that
393      size. */
394   switch (algo)
395     {
396     case 7: case 8: case 9: /* AES */
397     case 10: /* Twofish */
398     case 11: case 12: case 13: /* Camellia */
399       return 16;
400
401     default:
402       return 8;
403     }
404 }
405
406 /****************
407  * Wrapper around the libgcrypt function with additonal checks on
408  * the OpenPGP contraints for the algo ID.
409  */
410 int
411 openpgp_cipher_test_algo( int algo )
412 {
413   /* (5 and 6 are marked reserved by rfc4880.)  */
414   if ( algo < 0 || algo > 110 || algo == 5 || algo == 6 )
415     return gpg_error (GPG_ERR_CIPHER_ALGO);
416
417   return gcry_cipher_test_algo (map_cipher_openpgp_to_gcry (algo));
418 }
419
420 /* Map the OpenPGP cipher algorithm whose ID is contained in ALGORITHM to a
421    string representation of the algorithm name.  For unknown algorithm
422    IDs this function returns "?".  */
423 const char *
424 openpgp_cipher_algo_name (int algo) 
425 {
426   return gnupg_cipher_algo_name (map_cipher_openpgp_to_gcry (algo));
427 }
428
429 int
430 openpgp_pk_test_algo( int algo )
431 {
432   /* Dont't allow type 20 keys unless in rfc2440 mode.  */
433   if (!RFC2440 && algo == 20)
434     return gpg_error (GPG_ERR_PUBKEY_ALGO);
435     
436   if (algo == GCRY_PK_ELG_E)
437     algo = GCRY_PK_ELG;
438
439   if (algo < 0 || algo > 110)
440     return gpg_error (GPG_ERR_PUBKEY_ALGO);
441
442   return gcry_pk_test_algo (map_pk_openpgp_to_gcry (algo));
443 }
444
445 int
446 openpgp_pk_test_algo2( int algo, unsigned int use )
447 {
448   size_t use_buf = use;
449
450   /* Dont't allow type 20 keys unless in rfc2440 mode.  */
451   if (!RFC2440 && algo == 20)
452     return gpg_error (GPG_ERR_PUBKEY_ALGO);
453
454   if (algo == GCRY_PK_ELG_E)
455     algo = GCRY_PK_ELG;
456
457   if (algo < 0 || algo > 110)
458     return gpg_error (GPG_ERR_PUBKEY_ALGO);
459
460   return gcry_pk_algo_info (map_pk_openpgp_to_gcry (algo),
461                             GCRYCTL_TEST_ALGO, NULL, &use_buf);
462 }
463
464 int 
465 openpgp_pk_algo_usage ( int algo )
466 {
467     int use = 0; 
468     
469     /* They are hardwired in gpg 1.0. */
470     switch ( algo ) {    
471       case PUBKEY_ALGO_RSA:
472           use = (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG
473                  | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH);
474           break;
475       case PUBKEY_ALGO_RSA_E:
476       case PUBKEY_ALGO_ECDH:
477           use = PUBKEY_USAGE_ENC;
478           break;
479       case PUBKEY_ALGO_RSA_S:
480           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG;
481           break;
482       case PUBKEY_ALGO_ELGAMAL:
483           if (RFC2440)
484              use = PUBKEY_USAGE_ENC;
485           break;
486       case PUBKEY_ALGO_ELGAMAL_E:
487           use = PUBKEY_USAGE_ENC;
488           break;
489       case PUBKEY_ALGO_DSA:  
490           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
491           break;
492       case PUBKEY_ALGO_ECDSA:
493           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
494       default:
495           break;
496     }
497     return use;
498 }
499
500 /* Map the OpenPGP pubkey algorithm whose ID is contained in ALGO to a
501    string representation of the algorithm name.  For unknown algorithm
502    IDs this function returns "?".  */
503 const char *
504 openpgp_pk_algo_name (int algo) 
505 {
506   /* We use fixed strings to have pretty names instead of those from
507      libgcrypt.  */
508   switch (algo)
509     {    
510     case PUBKEY_ALGO_RSA:
511     case PUBKEY_ALGO_RSA_E:
512     case PUBKEY_ALGO_RSA_S: return "rsa";
513
514     case PUBKEY_ALGO_ELGAMAL:
515     case PUBKEY_ALGO_ELGAMAL_E: return "elg";
516
517     case PUBKEY_ALGO_DSA:  return "dsa";
518
519     case PUBKEY_ALGO_ECDSA:return "ecdsa";
520
521     case PUBKEY_ALGO_ECDH: return "ecdh";
522
523     default: gcry_pk_algo_name (map_pk_openpgp_to_gcry (algo));
524     }
525 }
526
527
528 int
529 openpgp_md_test_algo( int algo )
530 {
531   /* Note: If the list of actual supported OpenPGP algorithms changes,
532      make sure that our hard coded values at
533      print_status_begin_signing() gets updated. */
534   /* 4, 5, 6, 7 are defined by rfc2440 but will be removed from the
535      next revision of the standard.  */
536   if (algo < 0 || algo > 110 || (algo >= 4 && algo <= 7))
537     return gpg_error (GPG_ERR_DIGEST_ALGO);
538   return gcry_md_test_algo (algo);
539 }
540
541
542 /* Map the OpenPGP digest algorithm whose ID is contained in ALGO to a
543    string representation of the algorithm name.  For unknown algorithm
544    IDs this function returns "?".  */
545 const char *
546 openpgp_md_algo_name (int algo) 
547 {
548   if (algo < 0 || algo > 110)
549     return "?";
550   return gcry_md_algo_name (algo);
551 }
552
553
554 #ifdef USE_IDEA
555 /* Special warning for the IDEA cipher */
556 void
557 idea_cipher_warn(int show)
558 {
559   static int warned=0;
560
561   if(!warned || show)
562     {
563       log_info(_("the IDEA cipher plugin is not present\n"));
564       log_info(_("please see %s for more information\n"),
565                "http://www.gnupg.org/faq/why-not-idea.html");
566       warned=1;
567     }
568 }
569 #endif
570
571
572 static unsigned long 
573 get_signature_count (PKT_public_key *pk)
574 {
575 #ifdef ENABLE_CARD_SUPPORT
576   struct agent_card_info_s info;
577 #warning fixme: We should check that the correct card has been inserted
578   if (!agent_scd_getattr ("SIG-COUNTER",&info))
579     return info.sig_counter;
580   else
581     return 0;
582 #else
583   (void)pk;
584   return 0;
585 #endif
586 }
587
588 /* Expand %-strings.  Returns a string which must be xfreed.  Returns
589    NULL if the string cannot be expanded (too large). */
590 char *
591 pct_expando(const char *string,struct expando_args *args)
592 {
593   const char *ch=string;
594   int idx=0,maxlen=0,done=0;
595   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
596   char *ret=NULL;
597
598   if(args->pk)
599     keyid_from_pk(args->pk,pk_keyid);
600
601   if(args->pksk)
602     keyid_from_pk (args->pksk, sk_keyid);
603
604   /* This is used so that %k works in photoid command strings in
605      --list-secret-keys (which of course has a sk, but no pk). */
606   if(!args->pk && args->pksk)
607     keyid_from_pk (args->pksk, pk_keyid);
608
609   while(*ch!='\0')
610     {
611       if(!done)
612         {
613           /* 8192 is way bigger than we'll need here */
614           if(maxlen>=8192)
615             goto fail;
616
617           maxlen+=1024;
618           ret=xrealloc(ret,maxlen);
619         }
620
621       done=0;
622
623       if(*ch=='%')
624         {
625           switch(*(ch+1))
626             {
627             case 's': /* short key id */
628               if(idx+8<maxlen)
629                 {
630                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
631                   idx+=8;
632                   done=1;
633                 }
634               break;
635
636             case 'S': /* long key id */
637               if(idx+16<maxlen)
638                 {
639                   sprintf(&ret[idx],"%08lX%08lX",
640                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
641                   idx+=16;
642                   done=1;
643                 }
644               break;
645
646             case 'k': /* short key id */
647               if(idx+8<maxlen)
648                 {
649                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
650                   idx+=8;
651                   done=1;
652                 }
653               break;
654
655             case 'K': /* long key id */
656               if(idx+16<maxlen)
657                 {
658                   sprintf(&ret[idx],"%08lX%08lX",
659                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
660                   idx+=16;
661                   done=1;
662                 }
663               break;
664
665             case 'c': /* signature count from card, if any. */
666               if(idx+10<maxlen)
667                 {
668                   sprintf (&ret[idx],"%lu", get_signature_count (args->pksk));
669                   idx+=strlen(&ret[idx]);
670                   done=1;
671                 }             
672               break;
673
674             case 'p': /* primary pk fingerprint of a sk */
675             case 'f': /* pk fingerprint */
676             case 'g': /* sk fingerprint */
677               {
678                 byte array[MAX_FINGERPRINT_LEN];
679                 size_t len;
680                 int i;
681
682                 if((*(ch+1))=='p' && args->pksk)
683                   {
684                     if(args->pksk->flags.primary)
685                       fingerprint_from_pk (args->pksk, array, &len);
686                     else if (args->pksk->main_keyid[0]
687                              || args->pksk->main_keyid[1])
688                       {
689                         /* FIXME: Document teh code and check whether
690                            it is still needed.  */
691                         PKT_public_key *pk=
692                           xmalloc_clear(sizeof(PKT_public_key));
693
694                         if (!get_pubkey_fast (pk,args->pksk->main_keyid))
695                           fingerprint_from_pk (pk, array, &len);
696                         else
697                           memset (array, 0, (len=MAX_FINGERPRINT_LEN));
698                         free_public_key (pk);
699                       }
700                     else
701                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
702                   }
703                 else if((*(ch+1))=='f' && args->pk)
704                   fingerprint_from_pk (args->pk, array, &len);
705                 else if((*(ch+1))=='g' && args->pksk)
706                   fingerprint_from_pk (args->pksk, array, &len);
707                 else
708                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
709
710                 if(idx+(len*2)<maxlen)
711                   {
712                     for(i=0;i<len;i++)
713                       {
714                         sprintf(&ret[idx],"%02X",array[i]);
715                         idx+=2;
716                       }
717                     done=1;
718                   }
719               }
720               break;
721
722             case 'v': /* validity letters */
723               if(args->validity_info && idx+1<maxlen)
724                 {
725                   ret[idx++]=args->validity_info;
726                   ret[idx]='\0';
727                   done=1;
728                 }
729               break;
730
731               /* The text string types */
732             case 't':
733             case 'T':
734             case 'V':
735               {
736                 const char *str=NULL;
737
738                 switch(*(ch+1))
739                   {
740                   case 't': /* e.g. "jpg" */
741                     str=image_type_to_string(args->imagetype,0);
742                     break;
743                   
744                   case 'T': /* e.g. "image/jpeg" */
745                     str=image_type_to_string(args->imagetype,2);
746                     break;
747
748                   case 'V': /* e.g. "full", "expired", etc. */
749                     str=args->validity_string;
750                     break;
751                   }
752
753                 if(str && idx+strlen(str)<maxlen)
754                   {
755                     strcpy(&ret[idx],str);
756                     idx+=strlen(str);
757                     done=1;
758                   }
759               }
760               break;
761
762             case '%':
763               if(idx+1<maxlen)
764                 {
765                   ret[idx++]='%';
766                   ret[idx]='\0';
767                   done=1;
768                 }
769               break;
770
771               /* Any unknown %-keys (like %i, %o, %I, and %O) are
772                  passed through for later expansion.  Note this also
773                  handles the case where the last character in the
774                  string is a '%' - the terminating \0 will end up here
775                  and properly terminate the string. */
776             default:
777               if(idx+2<maxlen)
778                 {
779                   ret[idx++]='%';
780                   ret[idx++]=*(ch+1);
781                   ret[idx]='\0';
782                   done=1;
783                 }
784               break;
785               }
786
787           if(done)
788             ch++;
789         }
790       else
791         {
792           if(idx+1<maxlen)
793             {
794               ret[idx++]=*ch;
795               ret[idx]='\0';
796               done=1;
797             }
798         }
799
800       if(done)
801         ch++;
802     }
803
804   return ret;
805
806  fail:
807   xfree(ret);
808   return NULL;
809 }
810
811 void
812 deprecated_warning(const char *configname,unsigned int configlineno,
813                    const char *option,const char *repl1,const char *repl2)
814 {
815   if(configname)
816     {
817       if(strncmp("--",option,2)==0)
818         option+=2;
819
820       if(strncmp("--",repl1,2)==0)
821         repl1+=2;
822
823       log_info(_("%s:%d: deprecated option \"%s\"\n"),
824                configname,configlineno,option);
825     }
826   else
827     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
828
829   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
830 }
831
832
833 void
834 deprecated_command (const char *name)
835 {
836   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
837            name);
838 }
839
840
841 void
842 obsolete_option (const char *configname, unsigned int configlineno, 
843                  const char *name)
844 {
845   if(configname)
846     log_info (_("%s:%u: obsolete option \"%s\" - it has no effect\n"),
847               configname, configlineno, name);
848   else
849     log_info (_("WARNING: \"%s\" is an obsolete option - it has no effect\n"),
850               name);
851 }
852
853
854 /*
855  * Wrapper around gcry_cipher_map_name to provide a fallback using the
856  * "Sn" syntax as used by the preference strings.
857  */
858 int 
859 string_to_cipher_algo (const char *string) 
860
861   int val;
862
863   val = map_cipher_gcry_to_openpgp (gcry_cipher_map_name (string));
864   if (!val && string && (string[0]=='S' || string[0]=='s'))
865     {
866       char *endptr;
867
868       string++;
869       val = strtol (string, &endptr, 10);
870       if (!*string || *endptr || openpgp_cipher_test_algo (val))
871         val = 0;
872     }
873
874   return val;
875 }
876
877 /*
878  * Wrapper around gcry_md_map_name to provide a fallback using the
879  * "Hn" syntax as used by the preference strings.
880  */
881 int 
882 string_to_digest_algo (const char *string) 
883
884   int val;
885
886   val = gcry_md_map_name (string);
887   if (!val && string && (string[0]=='H' || string[0]=='h'))
888     {
889       char *endptr;
890
891       string++;
892       val = strtol (string, &endptr, 10);
893       if (!*string || *endptr || openpgp_md_test_algo (val))
894         val = 0;
895     }
896
897   return val;
898 }
899
900
901
902 const char *
903 compress_algo_to_string(int algo)
904 {
905   const char *s=NULL;
906
907   switch(algo)
908     {
909     case COMPRESS_ALGO_NONE:
910       s=_("Uncompressed");
911       break;
912
913     case COMPRESS_ALGO_ZIP:
914       s="ZIP";
915       break;
916
917     case COMPRESS_ALGO_ZLIB:
918       s="ZLIB";
919       break;
920
921 #ifdef HAVE_BZIP2
922     case COMPRESS_ALGO_BZIP2:
923       s="BZIP2";
924       break;
925 #endif
926     }
927
928   return s;
929 }
930
931 int
932 string_to_compress_algo(const char *string)
933 {
934   /* TRANSLATORS: See doc/TRANSLATE about this string. */
935   if(match_multistr(_("uncompressed|none"),string))
936     return 0;
937   else if(ascii_strcasecmp(string,"uncompressed")==0)
938     return 0;
939   else if(ascii_strcasecmp(string,"none")==0)
940     return 0;
941   else if(ascii_strcasecmp(string,"zip")==0)
942     return 1;
943   else if(ascii_strcasecmp(string,"zlib")==0)
944     return 2;
945 #ifdef HAVE_BZIP2
946   else if(ascii_strcasecmp(string,"bzip2")==0)
947     return 3;
948 #endif
949   else if(ascii_strcasecmp(string,"z0")==0)
950     return 0;
951   else if(ascii_strcasecmp(string,"z1")==0)
952     return 1;
953   else if(ascii_strcasecmp(string,"z2")==0)
954     return 2;
955 #ifdef HAVE_BZIP2
956   else if(ascii_strcasecmp(string,"z3")==0)
957     return 3;
958 #endif
959   else
960     return -1;
961 }
962
963 int
964 check_compress_algo(int algo)
965 {
966   switch (algo)
967     {
968     case 0: return 0;
969 #ifdef HAVE_ZIP
970     case 1:  
971     case 2: return 0;
972 #endif
973 #ifdef HAVE_BZIP2
974     case 3: return 0;
975 #endif
976     default: return G10ERR_COMPR_ALGO;
977     }
978 }
979
980 int
981 default_cipher_algo(void)
982 {
983   if(opt.def_cipher_algo)
984     return opt.def_cipher_algo;
985   else if(opt.personal_cipher_prefs)
986     return opt.personal_cipher_prefs[0].value;
987   else
988     return opt.s2k_cipher_algo;
989 }
990
991 /* There is no default_digest_algo function, but see
992    sign.c:hash_for() */
993
994 int
995 default_compress_algo(void)
996 {
997   if(opt.compress_algo!=-1)
998     return opt.compress_algo;
999   else if(opt.personal_compress_prefs)
1000     return opt.personal_compress_prefs[0].value;
1001   else
1002     return DEFAULT_COMPRESS_ALGO;
1003 }
1004
1005 const char *
1006 compliance_option_string(void)
1007 {
1008   char *ver="???";
1009
1010   switch(opt.compliance)
1011     {
1012     case CO_GNUPG:   return "--gnupg";
1013     case CO_RFC4880: return "--openpgp";
1014     case CO_RFC2440: return "--rfc2440";
1015     case CO_RFC1991: return "--rfc1991";
1016     case CO_PGP2:    return "--pgp2";
1017     case CO_PGP6:    return "--pgp6";
1018     case CO_PGP7:    return "--pgp7";
1019     case CO_PGP8:    return "--pgp8";
1020     }
1021
1022   return ver;
1023 }
1024
1025 void
1026 compliance_failure(void)
1027 {
1028   char *ver="???";
1029
1030   switch(opt.compliance)
1031     {
1032     case CO_GNUPG:
1033       ver="GnuPG";
1034       break;
1035
1036     case CO_RFC4880:
1037       ver="OpenPGP";
1038       break;
1039
1040     case CO_RFC2440:
1041       ver="OpenPGP (older)";
1042       break;
1043
1044     case CO_RFC1991:
1045       ver="old PGP";
1046       break;
1047
1048     case CO_PGP2:
1049       ver="PGP 2.x";
1050       break;
1051
1052     case CO_PGP6:
1053       ver="PGP 6.x";
1054       break;
1055
1056     case CO_PGP7:
1057       ver="PGP 7.x";
1058       break;
1059
1060     case CO_PGP8:
1061       ver="PGP 8.x";
1062       break;
1063     }
1064
1065   log_info(_("this message may not be usable by %s\n"),ver);
1066   opt.compliance=CO_GNUPG;
1067 }
1068
1069 /* Break a string into successive option pieces.  Accepts single word
1070    options and key=value argument options. */
1071 char *
1072 optsep(char **stringp)
1073 {
1074   char *tok,*end;
1075
1076   tok=*stringp;
1077   if(tok)
1078     {
1079       end=strpbrk(tok," ,=");
1080       if(end)
1081         {
1082           int sawequals=0;
1083           char *ptr=end;
1084
1085           /* what we need to do now is scan along starting with *end,
1086              If the next character we see (ignoring spaces) is an =
1087              sign, then there is an argument. */
1088
1089           while(*ptr)
1090             {
1091               if(*ptr=='=')
1092                 sawequals=1;
1093               else if(*ptr!=' ')
1094                 break;
1095               ptr++;
1096             }
1097
1098           /* There is an argument, so grab that too.  At this point,
1099              ptr points to the first character of the argument. */
1100           if(sawequals)
1101             {
1102               /* Is it a quoted argument? */
1103               if(*ptr=='"')
1104                 {
1105                   ptr++;
1106                   end=strchr(ptr,'"');
1107                   if(end)
1108                     end++;
1109                 }
1110               else
1111                 end=strpbrk(ptr," ,");
1112             }
1113
1114           if(end && *end)
1115             {
1116               *end='\0';
1117               *stringp=end+1;
1118             }
1119           else
1120             *stringp=NULL;
1121         }
1122       else
1123         *stringp=NULL;
1124     }
1125
1126   return tok;
1127 }
1128
1129 /* Breaks an option value into key and value.  Returns NULL if there
1130    is no value.  Note that "string" is modified to remove the =value
1131    part. */
1132 char *
1133 argsplit(char *string)
1134 {
1135   char *equals,*arg=NULL;
1136
1137   equals=strchr(string,'=');
1138   if(equals)
1139     {
1140       char *quote,*space;
1141
1142       *equals='\0';
1143       arg=equals+1;
1144
1145       /* Quoted arg? */
1146       quote=strchr(arg,'"');
1147       if(quote)
1148         {
1149           arg=quote+1;
1150
1151           quote=strchr(arg,'"');
1152           if(quote)
1153             *quote='\0';
1154         }
1155       else
1156         {
1157           size_t spaces;
1158
1159           /* Trim leading spaces off of the arg */
1160           spaces=strspn(arg," ");
1161           arg+=spaces;
1162         }
1163
1164       /* Trim tailing spaces off of the tag */
1165       space=strchr(string,' ');
1166       if(space)
1167         *space='\0';
1168     }
1169
1170   return arg;
1171 }
1172
1173 /* Return the length of the initial token, leaving off any
1174    argument. */
1175 static size_t
1176 optlen(const char *s)
1177 {
1178   char *end=strpbrk(s," =");
1179
1180   if(end)
1181     return end-s;
1182   else
1183     return strlen(s);
1184 }
1185
1186 int
1187 parse_options(char *str,unsigned int *options,
1188               struct parse_options *opts,int noisy)
1189 {
1190   char *tok;
1191
1192   if (str && !strcmp (str, "help"))
1193     {
1194       int i,maxlen=0;
1195
1196       /* Figure out the longest option name so we can line these up
1197          neatly. */
1198       for(i=0;opts[i].name;i++)
1199         if(opts[i].help && maxlen<strlen(opts[i].name))
1200           maxlen=strlen(opts[i].name);
1201
1202       for(i=0;opts[i].name;i++)
1203         if(opts[i].help)
1204           printf("%s%*s%s\n",opts[i].name,
1205                  maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1206
1207       g10_exit(0);
1208     }
1209
1210   while((tok=optsep(&str)))
1211     {
1212       int i,rev=0;
1213       char *otok=tok;
1214
1215       if(tok[0]=='\0')
1216         continue;
1217
1218       if(ascii_strncasecmp("no-",tok,3)==0)
1219         {
1220           rev=1;
1221           tok+=3;
1222         }
1223
1224       for(i=0;opts[i].name;i++)
1225         {
1226           size_t toklen=optlen(tok);
1227
1228           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1229             {
1230               /* We have a match, but it might be incomplete */
1231               if(toklen!=strlen(opts[i].name))
1232                 {
1233                   int j;
1234
1235                   for(j=i+1;opts[j].name;j++)
1236                     {
1237                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1238                         {
1239                           if(noisy)
1240                             log_info(_("ambiguous option `%s'\n"),otok);
1241                           return 0;
1242                         }
1243                     }
1244                 }
1245
1246               if(rev)
1247                 {
1248                   *options&=~opts[i].bit;
1249                   if(opts[i].value)
1250                     *opts[i].value=NULL;
1251                 }
1252               else
1253                 {
1254                   *options|=opts[i].bit;
1255                   if(opts[i].value)
1256                     *opts[i].value=argsplit(tok);
1257                 }
1258               break;
1259             }
1260         }
1261
1262       if(!opts[i].name)
1263         {
1264           if(noisy)
1265             log_info(_("unknown option `%s'\n"),otok);
1266           return 0;
1267         }
1268     }
1269
1270   return 1;
1271 }
1272
1273
1274 /* Check whether the string has characters not valid in an RFC-822
1275    address.  To cope with OpenPGP we ignore non-ascii characters
1276    so that for example umlauts are legal in an email address.  An
1277    OpenPGP user ID must be utf-8 encoded but there is no strict
1278    requirement for RFC-822.  Thus to avoid IDNA encoding we put the
1279    address verbatim as utf-8 into the user ID under the assumption
1280    that mail programs handle IDNA at a lower level and take OpenPGP
1281    user IDs as utf-8.  Note that we can't do an utf-8 encoding
1282    checking here because in keygen.c this function is called with the
1283    native encoding and native to utf-8 encoding is only done  later.  */
1284 int
1285 has_invalid_email_chars (const char *s)
1286 {
1287   int at_seen=0;
1288   const char *valid_chars=
1289     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1290
1291   for ( ; *s; s++ ) 
1292     {
1293       if ( (*s & 0x80) )
1294         continue; /* We only care about ASCII.  */
1295       if ( *s == '@' )
1296         at_seen=1;
1297       else if ( !at_seen && !( !!strchr( valid_chars, *s ) || *s == '+' ) )
1298         return 1;
1299       else if ( at_seen && !strchr( valid_chars, *s ) )
1300         return 1;
1301     }
1302   return 0;
1303 }
1304
1305
1306 /* Check whether NAME represents a valid mailbox according to
1307    RFC822. Returns true if so. */
1308 int
1309 is_valid_mailbox (const char *name)
1310 {
1311   return !( !name
1312             || !*name
1313             || has_invalid_email_chars (name)
1314             || string_count_chr (name,'@') != 1
1315             || *name == '@'
1316             || name[strlen(name)-1] == '@'
1317             || name[strlen(name)-1] == '.'
1318             || strstr (name, "..") );
1319 }
1320
1321
1322 /* Similar to access(2), but uses PATH to find the file. */
1323 int
1324 path_access(const char *file,int mode)
1325 {
1326   char *envpath;
1327   int ret=-1;
1328
1329   envpath=getenv("PATH");
1330
1331   if(!envpath
1332 #ifdef HAVE_DRIVE_LETTERS
1333      || (((file[0]>='A' && file[0]<='Z')
1334           || (file[0]>='a' && file[0]<='z'))
1335          && file[1]==':')
1336 #else
1337      || file[0]=='/'
1338 #endif
1339      )
1340     return access(file,mode);
1341   else
1342     {
1343       /* At least as large as, but most often larger than we need. */
1344       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1345       char *split,*item,*path=xstrdup(envpath);
1346
1347       split=path;
1348
1349       while((item=strsep(&split,PATHSEP_S)))
1350         {
1351           strcpy(buffer,item);
1352           strcat(buffer,"/");
1353           strcat(buffer,file);
1354           ret=access(buffer,mode);
1355           if(ret==0)
1356             break;
1357         }
1358
1359       xfree(path);
1360       xfree(buffer);
1361     }
1362
1363   return ret;
1364 }
1365
1366
1367 \f
1368 /* Temporary helper. */
1369 int
1370 pubkey_get_npkey( int algo )
1371 {
1372   size_t n;
1373
1374   if (algo == GCRY_PK_ELG_E)
1375     algo = GCRY_PK_ELG;
1376   else if (algo == PUBKEY_ALGO_ECDSA)
1377     algo = GCRY_PK_ECDSA;
1378   else if (algo == PUBKEY_ALGO_ECDH)
1379     algo = GCRY_PK_ECDH;
1380   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &n))
1381     n = 0;
1382   return n;
1383 }
1384
1385 /* Temporary helper. */
1386 int
1387 pubkey_get_nskey( int algo )
1388 {
1389   size_t n;
1390
1391   if (algo == GCRY_PK_ELG_E)
1392     algo = GCRY_PK_ELG;
1393   else if (algo == PUBKEY_ALGO_ECDSA)
1394     algo = GCRY_PK_ECDSA;
1395   else if (algo == PUBKEY_ALGO_ECDH)
1396     algo = GCRY_PK_ECDH;
1397   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &n ))
1398     n = 0;
1399   return n;
1400 }
1401
1402 /* Temporary helper. */
1403 int
1404 pubkey_get_nsig( int algo )
1405 {
1406   size_t n;
1407
1408   if (algo == GCRY_PK_ELG_E)
1409     algo = GCRY_PK_ELG;
1410   else if (algo == PUBKEY_ALGO_ECDSA)
1411     algo = GCRY_PK_ECDSA;
1412   else if (algo == PUBKEY_ALGO_ECDH)
1413     algo = GCRY_PK_ECDH;
1414   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSIGN, NULL, &n))
1415     n = 0;
1416   return n;
1417 }
1418
1419 /* Temporary helper. */
1420 int
1421 pubkey_get_nenc( int algo )
1422 {
1423   size_t n;
1424   
1425   if (algo == GCRY_PK_ELG_E)
1426     algo = GCRY_PK_ELG;
1427   else if (algo == PUBKEY_ALGO_ECDSA)
1428     algo = GCRY_PK_ECDSA;
1429   else if (algo == PUBKEY_ALGO_ECDH)
1430     algo = GCRY_PK_ECDH;
1431   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NENCR, NULL, &n ))
1432     n = 0;
1433   return n;
1434 }
1435
1436
1437 /* Temporary helper. */
1438 unsigned int
1439 pubkey_nbits( int algo, gcry_mpi_t *key )
1440 {
1441     int rc, nbits;
1442     gcry_sexp_t sexp;
1443
1444 #warning Why this assert
1445     assert( algo != GCRY_PK_ECDSA && algo != GCRY_PK_ECDH );
1446
1447     if( algo == GCRY_PK_DSA ) {
1448         rc = gcry_sexp_build ( &sexp, NULL,
1449                               "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1450                                   key[0], key[1], key[2], key[3] );
1451     }
1452     else if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E ) {
1453         rc = gcry_sexp_build ( &sexp, NULL,
1454                               "(public-key(elg(p%m)(g%m)(y%m)))",
1455                                   key[0], key[1], key[2] );
1456     }
1457     else if( algo == GCRY_PK_RSA ) {
1458         rc = gcry_sexp_build ( &sexp, NULL,
1459                               "(public-key(rsa(n%m)(e%m)))",
1460                                   key[0], key[1] );
1461     }
1462     else if( algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_ECDH ) {
1463         rc = gcry_sexp_build ( &sexp, NULL,
1464                               "(public-key(ecc(c%m)(q%m)))",
1465                                   key[0], key[1] /* not affecting the size calculation, so use 'ecc' == 'ecdsa' */ );
1466     }
1467     else
1468         return 0;
1469
1470     if ( rc )
1471         BUG ();
1472
1473     nbits = gcry_pk_get_nbits( sexp );
1474     gcry_sexp_release( sexp );
1475     return nbits;
1476 }
1477
1478
1479
1480 /* FIXME: Use gcry_mpi_print directly. */
1481 int
1482 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1483 {
1484   int n=0;
1485   
1486   if (!a)
1487     return es_fprintf (fp, "[MPI_NULL]");
1488   if (!mode)
1489     {
1490       unsigned int n1;
1491       n1 = gcry_mpi_get_nbits(a);
1492       n += es_fprintf (fp, "[%u bits]", n1);
1493     }
1494   else
1495     {
1496       unsigned char *buffer;
1497       
1498       if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a))
1499         BUG ();
1500       es_fputs (buffer, fp);
1501       n += strlen (buffer);
1502       gcry_free (buffer);
1503     }
1504   return n;
1505 }
1506
1507
1508 /*
1509  * Write a special size+body mpi A, to OUT.  The format of the content
1510  * of the MPI is one byte LEN, following by LEN bytes.
1511  */
1512 /* FIXME: Rename this function: it is not in iobuf.c */
1513 int
1514 iobuf_write_size_body_mpi (iobuf_t out, gcry_mpi_t a)
1515 {
1516   byte buffer[256]; /* Fixed buffer for a public parameter, max possible */
1517   size_t nbytes = (mpi_get_nbits (a)+7)/8;
1518   int rc;
1519
1520   if( nbytes > sizeof(buffer) )  {
1521       log_error("mpi with size+body is too large (%u bytes)\n", nbytes);
1522       return gpg_error (GPG_ERR_TOO_LARGE);
1523   }
1524   
1525   rc = gcry_mpi_print (GCRYMPI_FMT_USG, buffer, sizeof(buffer), &nbytes, a);
1526   if( rc )  {
1527     log_error("Failed to exported size+body mpi\n");
1528     return rc;
1529   }
1530   if( nbytes < 2 || buffer[0] != nbytes-1 )  {
1531     if( nbytes > 2 )
1532       log_error("Internal size mismatch in mpi size+body: %02x != %02x (other bytes: %02x %02x ... %02x %02x)\n", 
1533         buffer[0], nbytes-1, buffer[1], buffer[2], buffer[nbytes-2], buffer[nbytes-1]);
1534     else 
1535       log_error("Internal size mismatch in mpi size+body: only %d bytes\n", nbytes );
1536     return gpg_error (GPG_ERR_INV_DATA);
1537   }
1538   return iobuf_write( out, buffer, nbytes );
1539 }
1540
1541
1542 /*
1543  * Read a special size+body from inp into body[body_max_size] and
1544  * return it in a buffer and as MPI.  On success the number of
1545  * consumed bytes will body[0]+1.  The format of the content of the
1546  * returned MPI is one byte LEN, following by LEN bytes.  Caller is
1547  * expected to pre-allocate fixed-size 255 byte buffer (or smaller
1548  * when appropriate).
1549  */
1550 /* FIXME: Rename this function: it is not in iobuf.c */
1551 int
1552 iobuf_read_size_body (iobuf_t inp, byte *body, int body_max_size,
1553                       int pktlen, gcry_mpi_t *out )
1554 {
1555   unsigned n;
1556   int rc;
1557   gcry_mpi_t result;
1558
1559   *out = NULL;
1560
1561   if( (n = iobuf_readbyte(inp)) == -1 )
1562     {
1563       return G10ERR_INVALID_PACKET;
1564     }
1565   if ( n >= body_max_size || n < 2)
1566     {
1567       log_error("invalid size+body field\n");
1568       return G10ERR_INVALID_PACKET;
1569     }
1570   body[0] = n;  
1571   if ((n = iobuf_read(inp, body+1, n)) == -1)
1572     {
1573       log_error("invalid size+body field\n");
1574       return G10ERR_INVALID_PACKET;
1575     }
1576   if (n+1 > pktlen)
1577     {
1578       log_error("size+body field is larger than the packet\n");
1579       return G10ERR_INVALID_PACKET;
1580     }
1581   rc = gcry_mpi_scan (&result, GCRYMPI_FMT_USG, body, n+1, NULL);
1582   if (rc)
1583     log_fatal ("mpi_scan failed: %s\n", gpg_strerror (rc));
1584   
1585   *out = result;
1586   
1587   return rc;
1588 }
1589
1590
1591 /* pkey[1] or skey[1] is Q for ECDSA, which is an uncompressed point,
1592    i.e.  04 <x> <y> */
1593 int 
1594 ecdsa_qbits_from_Q (int qbits )
1595 {
1596   if ((qbits%8) > 3)
1597     {
1598       log_error(_("ECDSA public key is expected to be in SEC encoding "
1599                   "multiple of 8 bits\n"));
1600       return 0;
1601     }
1602   qbits -= qbits%8;
1603   qbits /= 2;
1604   return qbits;
1605 }