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