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