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