* gpgv.c (agent_scd_getattr): Stub.
[gnupg.git] / g10 / misc.c
1 /* misc.c -  miscellaneous functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004 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 2 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, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <errno.h>
28 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
29 #include <asm/sysinfo.h>
30 #include <asm/unistd.h>
31 #endif
32 #ifdef HAVE_SETRLIMIT
33 #include <time.h>
34 #include <sys/time.h>
35 #include <sys/resource.h>
36 #endif
37 #include "util.h"
38 #include "main.h"
39 #include "photoid.h"
40 #include "options.h"
41 #include "i18n.h"
42 #include "cardglue.h"
43
44 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
45 static int
46 setsysinfo(unsigned long op, void *buffer, unsigned long size,
47                      int *start, void *arg, unsigned long flag)
48 {
49     return syscall(__NR_osf_setsysinfo, op, buffer, size, start, arg, flag);
50 }
51
52 void
53 trap_unaligned(void)
54 {
55     unsigned int buf[2];
56
57     buf[0] = SSIN_UACPROC;
58     buf[1] = UAC_SIGBUS | UAC_NOPRINT;
59     setsysinfo(SSI_NVPAIRS, buf, 1, 0, 0, 0);
60 }
61 #else
62 void
63 trap_unaligned(void)
64 {  /* dummy */
65 }
66 #endif
67
68
69 int
70 disable_core_dumps()
71 {
72 #ifdef HAVE_DOSISH_SYSTEM
73     return 0;
74 #else
75 #ifdef HAVE_SETRLIMIT
76     struct rlimit limit;
77
78     limit.rlim_cur = 0;
79     limit.rlim_max = 0;
80     if( !setrlimit( RLIMIT_CORE, &limit ) )
81         return 0;
82     if( errno != EINVAL && errno != ENOSYS )
83         log_fatal(_("can't disable core dumps: %s\n"), strerror(errno) );
84 #endif
85     return 1;
86 #endif
87 }
88
89
90
91 u16
92 checksum_u16( unsigned n )
93 {
94     u16 a;
95
96     a  = (n >> 8) & 0xff;
97     a += n & 0xff;
98     return a;
99 }
100
101
102 u16
103 checksum( byte *p, unsigned n )
104 {
105     u16 a;
106
107     for(a=0; n; n-- )
108         a += *p++;
109     return a;
110 }
111
112 u16
113 checksum_mpi( MPI a )
114 {
115     u16 csum;
116     byte *buffer;
117     unsigned nbytes;
118     unsigned nbits;
119
120     buffer = mpi_get_buffer( a, &nbytes, NULL );
121     nbits = mpi_get_nbits(a);
122     csum = checksum_u16( nbits );
123     csum += checksum( buffer, nbytes );
124     m_free( buffer );
125     return csum;
126 }
127
128 u32
129 buffer_to_u32( const byte *buffer )
130 {
131     unsigned long a;
132     a =  *buffer << 24;
133     a |= buffer[1] << 16;
134     a |= buffer[2] << 8;
135     a |= buffer[3];
136     return a;
137 }
138
139
140 static void
141 no_exp_algo(void)
142 {
143     static int did_note = 0;
144
145     if( !did_note ) {
146         did_note = 1;
147         log_info(_("Experimental algorithms should not be used!\n"));
148     }
149 }
150
151 void
152 print_pubkey_algo_note( int algo )
153 {
154     if( algo >= 100 && algo <= 110 )
155         no_exp_algo();
156 }
157
158 void
159 print_cipher_algo_note( int algo )
160 {
161     if( algo >= 100 && algo <= 110 )
162         no_exp_algo();
163     else if(    algo == CIPHER_ALGO_3DES
164              || algo == CIPHER_ALGO_CAST5
165              || algo == CIPHER_ALGO_BLOWFISH
166              || algo == CIPHER_ALGO_TWOFISH
167              || algo == CIPHER_ALGO_AES
168              || algo == CIPHER_ALGO_AES192
169              || algo == CIPHER_ALGO_AES256
170            )
171         ;
172     else {
173         static int did_note = 0;
174
175         if( !did_note ) {
176             did_note = 1;
177             log_info(_("this cipher algorithm is deprecated; "
178                        "please use a more standard one!\n"));
179         }
180     }
181 }
182
183 void
184 print_digest_algo_note( int algo )
185 {
186     if( algo >= 100 && algo <= 110 )
187         no_exp_algo();
188 }
189
190
191 /* Return a string which is used as a kind of process ID */
192 const byte *
193 get_session_marker( size_t *rlen )
194 {
195     static byte marker[SIZEOF_UNSIGNED_LONG*2];
196     static int initialized;
197
198     if ( !initialized ) {
199         volatile ulong aa, bb; /* we really want the uninitialized value */
200         ulong a, b;
201
202         initialized = 1;
203         /* also this marker is guessable it is not easy to use this 
204          * for a faked control packet because an attacker does not
205          * have enough control about the time the verification does 
206          * take place.  Of course, we can add just more random but 
207          * than we need the random generator even for verification
208          * tasks - which does not make sense. */
209         a = aa ^ (ulong)getpid();
210         b = bb ^ (ulong)time(NULL);
211         memcpy( marker, &a, SIZEOF_UNSIGNED_LONG );
212         memcpy( marker+SIZEOF_UNSIGNED_LONG, &b, SIZEOF_UNSIGNED_LONG );
213     }
214     *rlen = sizeof(marker);
215     return marker;
216 }
217
218 /****************
219  * Wrapper around the libgcrypt function with addional checks on
220  * openPGP contraints for the algo ID.
221  */
222 int
223 openpgp_cipher_test_algo( int algo )
224 {
225     if( algo < 0 || algo > 110 )
226         return G10ERR_CIPHER_ALGO;
227     return check_cipher_algo(algo);
228 }
229
230 int
231 openpgp_pk_test_algo( int algo, unsigned int usage_flags )
232 {
233     if( algo < 0 || algo > 110 )
234         return G10ERR_PUBKEY_ALGO;
235     return check_pubkey_algo2( algo, usage_flags );
236 }
237
238 int 
239 openpgp_pk_algo_usage ( int algo )
240 {
241     int use = 0; 
242     
243     /* they are hardwired in gpg 1.0 */
244     switch ( algo ) {    
245       case PUBKEY_ALGO_RSA:
246           use = PUBKEY_USAGE_SIG | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH;
247           break;
248       case PUBKEY_ALGO_RSA_E:
249           use = PUBKEY_USAGE_ENC;
250           break;
251       case PUBKEY_ALGO_RSA_S:
252           use = PUBKEY_USAGE_SIG;
253           break;
254       case PUBKEY_ALGO_ELGAMAL_E:
255           use = PUBKEY_USAGE_ENC;
256           break;
257       case PUBKEY_ALGO_DSA:  
258           use = PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
259           break;
260       default:
261           break;
262     }
263     return use;
264 }
265
266 int
267 openpgp_md_test_algo( int algo )
268 {
269     if( algo < 0 || algo > 110 )
270         return G10ERR_DIGEST_ALGO;
271     return check_digest_algo(algo);
272 }
273
274 #ifdef USE_IDEA
275 /* Special warning for the IDEA cipher */
276 void
277 idea_cipher_warn(int show)
278 {
279   static int warned=0;
280
281   if(!warned || show)
282     {
283       log_info(_("the IDEA cipher plugin is not present\n"));
284       log_info(_("please see http://www.gnupg.org/why-not-idea.html "
285                  "for more information\n"));
286       warned=1;
287     }
288 }
289 #endif
290
291 static unsigned long get_signature_count(PKT_secret_key *sk)
292 {
293 #ifdef ENABLE_CARD_SUPPORT
294   if(sk && sk->is_protected && sk->protect.s2k.mode==1002)
295     {
296       struct agent_card_info_s info;
297       if(agent_scd_getattr("SIG-COUNTER",&info)==0)
298         return info.sig_counter;
299     }  
300 #endif
301
302   /* How to do this without a card? */
303
304   return 0;
305 }
306
307 /* Expand %-strings.  Returns a string which must be m_freed.  Returns
308    NULL if the string cannot be expanded (too large). */
309 char *
310 pct_expando(const char *string,struct expando_args *args)
311 {
312   const char *ch=string;
313   int idx=0,maxlen=0,done=0;
314   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
315   char *ret=NULL;
316
317   if(args->pk)
318     keyid_from_pk(args->pk,pk_keyid);
319
320   if(args->sk)
321     keyid_from_sk(args->sk,sk_keyid);
322
323   /* This is used so that %k works in photoid command strings in
324      --list-secret-keys (which of course has a sk, but no pk). */
325   if(!args->pk && args->sk)
326     keyid_from_sk(args->sk,pk_keyid);
327
328   while(*ch!='\0')
329     {
330       char *str=NULL;
331
332       if(!done)
333         {
334           /* 8192 is way bigger than we'll need here */
335           if(maxlen>=8192)
336             goto fail;
337
338           maxlen+=1024;
339           ret=m_realloc(ret,maxlen);
340         }
341
342       done=0;
343
344       if(*ch=='%')
345         {
346           switch(*(ch+1))
347             {
348             case 's': /* short key id */
349               if(idx+8<maxlen)
350                 {
351                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
352                   idx+=8;
353                   done=1;
354                 }
355               break;
356
357             case 'S': /* long key id */
358               if(idx+16<maxlen)
359                 {
360                   sprintf(&ret[idx],"%08lX%08lX",
361                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
362                   idx+=16;
363                   done=1;
364                 }
365               break;
366
367             case 'k': /* short key id */
368               if(idx+8<maxlen)
369                 {
370                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
371                   idx+=8;
372                   done=1;
373                 }
374               break;
375
376             case 'K': /* long key id */
377               if(idx+16<maxlen)
378                 {
379                   sprintf(&ret[idx],"%08lX%08lX",
380                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
381                   idx+=16;
382                   done=1;
383                 }
384               break;
385
386             case 'c': /* signature count from card, if any. */
387               if(idx+10<maxlen)
388                 {
389                   sprintf(&ret[idx],"%lu",get_signature_count(args->sk));
390                   idx+=strlen(&ret[idx]);
391                   done=1;
392                 }             
393               break;
394
395             case 'p': /* primary pk fingerprint of a sk */
396             case 'f': /* pk fingerprint */
397             case 'g': /* sk fingerprint */
398               {
399                 byte array[MAX_FINGERPRINT_LEN];
400                 size_t len;
401                 int i;
402
403                 if((*(ch+1))=='p' && args->sk)
404                   {
405                     if(args->sk->is_primary)
406                       fingerprint_from_sk(args->sk,array,&len);
407                     else if(args->sk->main_keyid[0] || args->sk->main_keyid[1])
408                       {
409                         PKT_public_key *pk=
410                           m_alloc_clear(sizeof(PKT_public_key));
411
412                         if(get_pubkey_fast(pk,args->sk->main_keyid)==0)
413                           fingerprint_from_pk(pk,array,&len);
414                         else
415                           memset(array,0,(len=MAX_FINGERPRINT_LEN));
416                         free_public_key(pk);
417                       }
418                     else
419                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
420                   }
421                 else if((*(ch+1))=='f' && args->pk)
422                   fingerprint_from_pk(args->pk,array,&len);
423                 else if((*(ch+1))=='g' && args->sk)
424                   fingerprint_from_sk(args->sk,array,&len);
425                 else
426                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
427
428                 if(idx+(len*2)<maxlen)
429                   {
430                     for(i=0;i<len;i++)
431                       {
432                         sprintf(&ret[idx],"%02X",array[i]);
433                         idx+=2;
434                       }
435                     done=1;
436                   }
437               }
438               break;
439
440             case 't': /* e.g. "jpg" */
441               str=image_type_to_string(args->imagetype,0);
442               /* fall through */
443
444             case 'T': /* e.g. "image/jpeg" */
445               if(str==NULL)
446                 str=image_type_to_string(args->imagetype,2);
447
448               if(idx+strlen(str)<maxlen)
449                 {
450                   strcpy(&ret[idx],str);
451                   idx+=strlen(str);
452                   done=1;
453                 }
454               break;
455
456             case '%':
457               if(idx+1<maxlen)
458                 {
459                   ret[idx++]='%';
460                   ret[idx]='\0';
461                   done=1;
462                 }
463               break;
464
465               /* Any unknown %-keys (like %i, %o, %I, and %O) are
466                  passed through for later expansion.  Note this also
467                  handles the case where the last character in the
468                  string is a '%' - the terminating \0 will end up here
469                  and properly terminate the string. */
470             default:
471               if(idx+2<maxlen)
472                 {
473                   ret[idx++]='%';
474                   ret[idx++]=*(ch+1);
475                   ret[idx]='\0';
476                   done=1;
477                 }
478               break;
479               }
480
481           if(done)
482             ch++;
483         }
484       else
485         {
486           if(idx+1<maxlen)
487             {
488               ret[idx++]=*ch;
489               ret[idx]='\0';
490               done=1;
491             }
492         }
493
494       if(done)
495         ch++;
496     }
497
498   return ret;
499
500  fail:
501   m_free(ret);
502   return NULL;
503 }
504
505 void
506 deprecated_warning(const char *configname,unsigned int configlineno,
507                    const char *option,const char *repl1,const char *repl2)
508 {
509   if(configname)
510     {
511       if(strncmp("--",option,2)==0)
512         option+=2;
513
514       if(strncmp("--",repl1,2)==0)
515         repl1+=2;
516
517       log_info(_("%s:%d: deprecated option \"%s\"\n"),
518                configname,configlineno,option);
519     }
520   else
521     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
522
523   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
524 }
525
526 const char *
527 compress_algo_to_string(int algo)
528 {
529   const char *s=NULL;
530
531   switch(algo)
532     {
533     case COMPRESS_ALGO_NONE:
534       s=_("Uncompressed");
535       break;
536
537     case COMPRESS_ALGO_ZIP:
538       s="ZIP";
539       break;
540
541     case COMPRESS_ALGO_ZLIB:
542       s="ZLIB";
543       break;
544
545 #ifdef HAVE_BZIP2
546     case COMPRESS_ALGO_BZIP2:
547       s="BZIP2";
548       break;
549 #endif
550     }
551
552   return s;
553 }
554
555 int
556 string_to_compress_algo(const char *string)
557 {
558   /* NOTE TO TRANSLATOR: See doc/TRANSLATE about this string. */
559   if(match_multistr(_("uncompressed|none"),string))
560     return 0;
561   else if(ascii_strcasecmp(string,"uncompressed")==0)
562     return 0;
563   else if(ascii_strcasecmp(string,"none")==0)
564     return 0;
565   else if(ascii_strcasecmp(string,"zip")==0)
566     return 1;
567   else if(ascii_strcasecmp(string,"zlib")==0)
568     return 2;
569 #ifdef HAVE_BZIP2
570   else if(ascii_strcasecmp(string,"bzip2")==0)
571     return 3;
572 #endif
573   else if(ascii_strcasecmp(string,"z0")==0)
574     return 0;
575   else if(ascii_strcasecmp(string,"z1")==0)
576     return 1;
577   else if(ascii_strcasecmp(string,"z2")==0)
578     return 2;
579 #ifdef HAVE_BZIP2
580   else if(ascii_strcasecmp(string,"z3")==0)
581     return 3;
582 #endif
583   else
584     return -1;
585 }
586
587 int
588 check_compress_algo(int algo)
589 {
590 #ifdef HAVE_BZIP2
591   if(algo>=0 && algo<=3)
592     return 0;
593 #else
594   if(algo>=0 && algo<=2)
595     return 0;
596 #endif
597
598   return G10ERR_COMPR_ALGO;
599 }
600
601 int
602 default_cipher_algo(void)
603 {
604   if(opt.def_cipher_algo)
605     return opt.def_cipher_algo;
606   else if(opt.personal_cipher_prefs)
607     return opt.personal_cipher_prefs[0].value;
608   else
609     return opt.s2k_cipher_algo;
610 }
611
612 /* There is no default_digest_algo function, but see
613    sign.c:hash_for() */
614
615 int
616 default_compress_algo(void)
617 {
618   if(opt.compress_algo!=-1)
619     return opt.compress_algo;
620   else if(opt.personal_compress_prefs)
621     return opt.personal_compress_prefs[0].value;
622   else
623     return DEFAULT_COMPRESS_ALGO;
624 }
625
626 const char *
627 compliance_option_string(void)
628 {
629   switch(opt.compliance)
630     {
631     case CO_RFC2440:
632       return "--openpgp";
633     case CO_PGP2:
634       return "--pgp2";
635     case CO_PGP6:
636       return "--pgp6";
637     case CO_PGP7:
638       return "--pgp7";
639     case CO_PGP8:
640       return "--pgp8";
641     default:
642       return "???";
643     }
644 }
645
646 static const char *
647 compliance_string(void)
648 {
649   switch(opt.compliance)
650     {
651     case CO_RFC2440:
652       return "OpenPGP";
653     case CO_PGP2:
654       return "PGP 2.x";
655     case CO_PGP6:
656       return "PGP 6.x";
657     case CO_PGP7:
658       return "PGP 7.x";
659     case CO_PGP8:
660       return "PGP 8.x";
661     default:
662       return "???";
663     }
664 }
665
666 void
667 compliance_failure(void)
668 {
669   log_info(_("this message may not be usable by %s\n"),compliance_string());
670   opt.compliance=CO_GNUPG;
671 }
672
673 /* Break a string into successive option pieces.  Accepts single word
674    options and key=value argument options. */
675 char *
676 optsep(char **stringp)
677 {
678   char *tok,*end;
679
680   tok=*stringp;
681   if(tok)
682     {
683       end=strpbrk(tok," ,=");
684       if(end)
685         {
686           int sawequals=0;
687           char *ptr=end;
688
689           /* what we need to do now is scan along starting with *end,
690              If the next character we see (ignoring spaces) is an =
691              sign, then there is an argument. */
692
693           while(*ptr)
694             {
695               if(*ptr=='=')
696                 sawequals=1;
697               else if(*ptr!=' ')
698                 break;
699               ptr++;
700             }
701
702           /* There is an argument, so grab that too.  At this point,
703              ptr points to the first character of the argument. */
704           if(sawequals)
705             {
706               /* Is it a quoted argument? */
707               if(*ptr=='"')
708                 {
709                   ptr++;
710                   end=strchr(ptr,'"');
711                   if(end)
712                     end++;
713                 }
714               else
715                 end=strpbrk(ptr," ,");
716             }
717
718           if(end && *end)
719             {
720               *end='\0';
721               *stringp=end+1;
722             }
723           else
724             *stringp=NULL;
725         }
726       else
727         *stringp=NULL;
728     }
729
730   return tok;
731 }
732
733 /* Breaks an option value into key and value.  Returns NULL if there
734    is no value.  Note that "string" is modified to remove the =value
735    part. */
736 char *
737 argsplit(char *string)
738 {
739   char *equals,*arg=NULL;
740
741   equals=strchr(string,'=');
742   if(equals)
743     {
744       char *quote,*space;
745
746       *equals='\0';
747       arg=equals+1;
748
749       /* Quoted arg? */
750       quote=strchr(arg,'"');
751       if(quote)
752         {
753           arg=quote+1;
754
755           quote=strchr(arg,'"');
756           if(quote)
757             *quote='\0';
758         }
759       else
760         {
761           size_t spaces;
762
763           /* Trim leading spaces off of the arg */
764           spaces=strspn(arg," ");
765           arg+=spaces;
766         }
767
768       /* Trim tailing spaces off of the tag */
769       space=strchr(string,' ');
770       if(space)
771         *space='\0';
772     }
773
774   return arg;
775 }
776
777 /* Return the length of the initial token, leaving off any
778    argument. */
779 static size_t
780 optlen(const char *s)
781 {
782   char *end=strpbrk(s," =");
783
784   if(end)
785     return end-s;
786   else
787     return strlen(s);
788 }
789
790 int
791 parse_options(char *str,unsigned int *options,
792               struct parse_options *opts,int noisy)
793 {
794   char *tok;
795
796   while((tok=optsep(&str)))
797     {
798       int i,rev=0;
799       char *otok=tok;
800
801       if(tok[0]=='\0')
802         continue;
803
804       if(ascii_strncasecmp("no-",tok,3)==0)
805         {
806           rev=1;
807           tok+=3;
808         }
809
810       for(i=0;opts[i].name;i++)
811         {
812           size_t toklen=optlen(tok);
813
814           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
815             {
816               /* We have a match, but it might be incomplete */
817               if(toklen!=strlen(opts[i].name))
818                 {
819                   int j;
820
821                   for(j=i+1;opts[j].name;j++)
822                     {
823                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
824                         {
825                           if(noisy)
826                             log_info(_("ambiguous option `%s'\n"),otok);
827                           return 0;
828                         }
829                     }
830                 }
831
832               if(rev)
833                 {
834                   *options&=~opts[i].bit;
835                   if(opts[i].value)
836                     *opts[i].value=NULL;
837                 }
838               else
839                 {
840                   *options|=opts[i].bit;
841                   if(opts[i].value)
842                     *opts[i].value=argsplit(tok);
843                 }
844               break;
845             }
846         }
847
848       if(!opts[i].name)
849         {
850           if(noisy)
851             log_info(_("unknown option `%s'\n"),otok);
852           return 0;
853         }
854     }
855
856   return 1;
857 }