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