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