cipher/md.c

   1 /* md.c  -  message digest dispatcher
   2  *      Copyright (C) 1998, 1999, 2002, 2003 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 <errno.h>
  26 #include <assert.h>
  27 #include "util.h"
  28 #include "cipher.h"
  29 #include "errors.h"
  30 #include "algorithms.h"
  31 #include "i18n.h"
  32
  33 /****************
  34  * This structure is used for the list of available algorithms
  35  * and for the list of algorithms in MD_HANDLE.
  36  */
  37 struct md_digest_list_s {
  38     struct md_digest_list_s *next;
  39     const char *name;
  40     int algo;
  41     byte *asnoid;
  42     int asnlen;
  43     int mdlen;
  44     void (*init)( void *c );
  45     void (*write)( void *c, byte *buf, size_t nbytes );
  46     void (*final)( void *c );
  47     byte *(*read)( void *c );
  48     size_t contextsize; /* allocate this amount of context */
  49     PROPERLY_ALIGNED_TYPE context;
  50 };
  51
  52 static struct md_digest_list_s *digest_list;
  53
  54
  55 static struct md_digest_list_s *
  56 new_list_item (int algo,
  57                const char *(*get_info)( int, size_t*,byte**, int*, int*,
  58                                        void (**)(void*),
  59                                        void (**)(void*,byte*,size_t),
  60                                        void (**)(void*),byte *(**)(void*)))
  61 {
  62   struct md_digest_list_s *r;
  63
  64   r = m_alloc_clear (sizeof *r );
  65   r->algo = algo;
  66   r->name = (*get_info)( algo, &r->contextsize,
  67                          &r->asnoid, &r->asnlen, &r->mdlen,
  68                          &r->init, &r->write, &r->final, &r->read );
  69   if (!r->name )
  70     {
  71       m_free(r);
  72       r = NULL;
  73     }
  74   if (r)
  75     {
  76       r->next = digest_list;
  77       digest_list = r;
  78     }
  79   return r;
  80 }
  81
  82
  83
  84 /*
  85   Load all available hash algorithms and return true.  Subsequent
  86   calls will return 0.
  87  */
  88 static int
  89 load_digest_module (void)
  90 {
  91   static int initialized = 0;
  92
  93   if (initialized)
  94     return 0;
  95   initialized = 1;
  96
  97   /* We load them in reverse order so that the most
  98      frequently used are the first in the list. */
  99 #ifdef USE_SHA512
 100   if (!new_list_item (DIGEST_ALGO_SHA512, sha512_get_info))
 101     BUG ();
 102   if (!new_list_item (DIGEST_ALGO_SHA384, sha384_get_info))
 103     BUG ();
 104 #endif
 105 #ifdef USE_SHA256
 106   if (!new_list_item (DIGEST_ALGO_SHA256, sha256_get_info))
 107     BUG ();
 108 #endif
 109   if (!new_list_item (DIGEST_ALGO_MD5, md5_get_info))
 110     BUG ();
 111   if (!new_list_item (DIGEST_ALGO_RMD160, rmd160_get_info))
 112     BUG ();
 113   if (!new_list_item (DIGEST_ALGO_SHA1, sha1_get_info))
 114     BUG ();
 115
 116   return 1;
 117 }
 118
 119
 120 /****************
 121  * Map a string to the digest algo */
 122 int
 123 string_to_digest_algo( const char *string )
 124 {
 125     struct md_digest_list_s *r;
 126
 127     /* Hi there.  I see you changing that code so you can use the new
 128        SHA hashes.  Before you do it, please think about it.  There
 129        are no official releases of any OpenPGP programs that generate
 130        these hashes, and we're trying to get a code base that can
 131        understand the hashes before we release one that generates
 132        them. - dshaw */
 133
 134     if(!ascii_strcasecmp("sha384",string)
 135        || !ascii_strcasecmp("sha512",string))
 136       {
 137         log_info(_("digest algorithm `%s' is read-only in this release\n"),
 138                  string);
 139         return 0;
 140       }
 141
 142     do {
 143         for(r = digest_list; r; r = r->next )
 144             if( !ascii_strcasecmp( r->name, string ) )
 145                 return r->algo;
 146     } while( !r && load_digest_module () );
 147
 148     /* Didn't find it, so try the Hx format */
 149     if(string[0]=='H' || string[0]=='h')
 150       {
 151         long val;
 152         char *endptr;
 153
 154         string++;
 155
 156         val=strtol(string,&endptr,10);
 157         if(*string!='\0' && *endptr=='\0' && check_digest_algo(val)==0)
 158           return val;
 159       }
 160
 161     return 0;
 162 }
 163
 164 /****************
 165  * Map a digest algo to a string
 166  */
 167 const char *
 168 digest_algo_to_string( int algo )
 169 {
 170     struct md_digest_list_s *r;
 171
 172     do {
 173         for(r = digest_list; r; r = r->next )
 174             if( r->algo == algo )
 175                 return r->name;
 176     } while( !r && load_digest_module () );
 177     return NULL;
 178 }
 179
 180
 181 int
 182 check_digest_algo( int algo )
 183 {
 184     struct md_digest_list_s *r;
 185
 186     do {
 187         for(r = digest_list; r; r = r->next )
 188             if( r->algo == algo )
 189                 return 0;
 190     } while( !r && load_digest_module () );
 191     return G10ERR_DIGEST_ALGO;
 192 }
 193
 194
 195
 196 /****************
 197  * Open a message digest handle for use with algorithm ALGO.
 198  * More algorithms may be added by md_enable(). The initial algorithm
 199  * may be 0.
 200  */
 201 MD_HANDLE
 202 md_open( int algo, int secure )
 203 {
 204     MD_HANDLE hd;
 205     int bufsize;
 206
 207     if( secure ) {
 208         bufsize = 512 - sizeof( *hd );
 209         hd = m_alloc_secure_clear( sizeof *hd + bufsize );
 210     }
 211     else {
 212         bufsize = 1024 - sizeof( *hd );
 213         hd = m_alloc_clear( sizeof *hd + bufsize );
 214     }
 215
 216     hd->bufsize = bufsize+1; /* hd has already one byte allocated */
 217     hd->secure = secure;
 218     if( algo )
 219         md_enable( hd, algo );
 220     fast_random_poll();
 221     return hd;
 222 }
 223
 224 void
 225 md_enable( MD_HANDLE h, int algo )
 226 {
 227     struct md_digest_list_s *r, *ac;
 228
 229     for( ac=h->list; ac; ac = ac->next )
 230         if( ac->algo == algo )
 231             return ; /* already enabled */
 232     /* find the algorithm */
 233     do {
 234         for(r = digest_list; r; r = r->next )
 235             if( r->algo == algo )
 236                 break;
 237     } while( !r && load_digest_module () );
 238     if( !r ) {
 239         log_error("md_enable: algorithm %d not available\n", algo );
 240         return;
 241     }
 242     /* and allocate a new list entry */
 243     ac = h->secure? m_alloc_secure( sizeof *ac + r->contextsize
 244                                                - sizeof(r->context) )
 245                   : m_alloc( sizeof *ac + r->contextsize
 246                                                - sizeof(r->context) );
 247     *ac = *r;
 248     ac->next = h->list;
 249     h->list = ac;
 250     /* and init this instance */
 251     (*ac->init)( &ac->context.c );
 252 }
 253
 254
 255 MD_HANDLE
 256 md_copy( MD_HANDLE a )
 257 {
 258     MD_HANDLE b;
 259     struct md_digest_list_s *ar, *br;
 260
 261     if( a->bufcount )
 262         md_write( a, NULL, 0 );
 263     b = a->secure ? m_alloc_secure( sizeof *b + a->bufsize - 1 )
 264                   : m_alloc( sizeof *b + a->bufsize - 1 );
 265     memcpy( b, a, sizeof *a + a->bufsize - 1 );
 266     b->list = NULL;
 267     b->debug = NULL;
 268     /* and now copy the complete list of algorithms */
 269     /* I know that the copied list is reversed, but that doesn't matter */
 270     for( ar=a->list; ar; ar = ar->next ) {
 271         br = a->secure ? m_alloc_secure( sizeof *br + ar->contextsize
 272                                                - sizeof(ar->context) )
 273                        : m_alloc( sizeof *br + ar->contextsize
 274                                                - sizeof(ar->context) );
 275         memcpy( br, ar, sizeof(*br) + ar->contextsize
 276                                     - sizeof(ar->context) );
 277         br->next = b->list;
 278         b->list = br;
 279     }
 280
 281     if( a->debug )
 282         md_start_debug( b, "unknown" );
 283     return b;
 284 }
 285
 286
 287 /****************
 288  * Reset all contexts and discard any buffered stuff.  This may be used
 289  * instead of a md_close(); md_open().
 290  */
 291 void
 292 md_reset( MD_HANDLE a )
 293 {
 294     struct md_digest_list_s *r;
 295
 296     a->bufcount = a->finalized = 0;
 297     for( r=a->list; r; r = r->next ) {
 298         memset( r->context.c, 0, r->contextsize );
 299         (*r->init)( &r->context.c );
 300     }
 301 }
 302
 303
 304 void
 305 md_close(MD_HANDLE a)
 306 {
 307     struct md_digest_list_s *r, *r2;
 308
 309     if( !a )
 310         return;
 311     if( a->debug )
 312         md_stop_debug(a);
 313     for(r=a->list; r; r = r2 ) {
 314         r2 = r->next;
 315         m_free(r);
 316     }
 317     m_free(a);
 318 }
 319
 320
 321 void
 322 md_write( MD_HANDLE a, const byte *inbuf, size_t inlen)
 323 {
 324     struct md_digest_list_s *r;
 325
 326     if( a->debug ) {
 327         if( a->bufcount && fwrite(a->buffer, a->bufcount, 1, a->debug ) != 1 )
 328             BUG();
 329         if( inlen && fwrite(inbuf, inlen, 1, a->debug ) != 1 )
 330             BUG();
 331     }
 332     for(r=a->list; r; r = r->next ) {
 333         (*r->write)( &r->context.c, a->buffer, a->bufcount );
 334         /* Fixme: all ->write fnc should take a const byte* */
 335         (*r->write)( &r->context.c, (byte*)inbuf, inlen );
 336     }
 337     a->bufcount = 0;
 338 }
 339
 340
 341
 342 void
 343 md_final(MD_HANDLE a)
 344 {
 345     struct md_digest_list_s *r;
 346
 347     if( a->finalized )
 348         return;
 349
 350     if( a->bufcount )
 351         md_write( a, NULL, 0 );
 352
 353     for(r=a->list; r; r = r->next ) {
 354         (*r->final)( &r->context.c );
 355     }
 356     a->finalized = 1;
 357 }
 358
 359
 360 /****************
 361  * if ALGO is null get the digest for the used algo (which should be only one)
 362  */
 363 byte *
 364 md_read( MD_HANDLE a, int algo )
 365 {
 366     struct md_digest_list_s *r;
 367
 368     if( !algo ) {  /* return the first algorithm */
 369         if( (r=a->list) ) {
 370             if( r->next )
 371                 log_debug("more than algorithm in md_read(0)\n");
 372             return (*r->read)( &r->context.c );
 373         }
 374     }
 375     else {
 376         for(r=a->list; r; r = r->next )
 377             if( r->algo == algo )
 378                 return (*r->read)( &r->context.c );
 379     }
 380     BUG();
 381     return NULL;
 382 }
 383
 384
 385 /****************
 386  * This function combines md_final and md_read but keeps the context
 387  * intact.  This function can be used to calculate intermediate
 388  * digests.  The digest is copied into buffer and the digestlength is
 389  * returned.  If buffer is NULL only the needed size for buffer is returned.
 390  * buflen gives the max size of buffer. If the buffer is too shourt to
 391  * hold the complete digest, the buffer is filled with as many bytes are
 392  * possible and this value is returned.
 393  */
 394 int
 395 md_digest( MD_HANDLE a, int algo, byte *buffer, int buflen )
 396 {
 397     struct md_digest_list_s *r = NULL;
 398     char *context;
 399     char *digest;
 400
 401     if( a->bufcount )
 402         md_write( a, NULL, 0 );
 403
 404     if( !algo ) {  /* return digest for the first algorithm */
 405         if( (r=a->list) && r->next )
 406             log_debug("more than algorithm in md_digest(0)\n");
 407     }
 408     else {
 409         for(r=a->list; r; r = r->next )
 410             if( r->algo == algo )
 411                 break;
 412     }
 413     if( !r )
 414         BUG();
 415
 416     if( !buffer )
 417         return r->mdlen;
 418
 419     /* I don't want to change the interface, so I simply work on a copy
 420      * the context (extra overhead - should be fixed)*/
 421     context = a->secure ? m_alloc_secure( r->contextsize )
 422                         : m_alloc( r->contextsize );
 423     memcpy( context, r->context.c, r->contextsize );
 424     (*r->final)( context );
 425     digest = (*r->read)( context );
 426
 427     if( buflen > r->mdlen )
 428         buflen = r->mdlen;
 429     memcpy( buffer, digest, buflen );
 430
 431     m_free(context);
 432     return buflen;
 433 }
 434
 435
 436 int
 437 md_get_algo( MD_HANDLE a )
 438 {
 439     struct md_digest_list_s *r;
 440
 441     if( (r=a->list) ) {
 442         if( r->next )
 443             log_error("WARNING: more than algorithm in md_get_algo()\n");
 444         return r->algo;
 445     }
 446     return 0;
 447 }
 448
 449 /* Returns true if a given algo is in use in a md */
 450 int
 451 md_algo_present( MD_HANDLE a, int algo )
 452 {
 453   struct md_digest_list_s *r=a->list;
 454
 455   while(r)
 456     {
 457       if(r->algo==algo)
 458         return 1;
 459
 460       r=r->next;
 461     }
 462
 463   return 0;
 464 }
 465
 466 /****************
 467  * Return the length of the digest
 468  */
 469 int
 470 md_digest_length( int algo )
 471 {
 472     struct md_digest_list_s *r;
 473
 474     do {
 475         for(r = digest_list; r; r = r->next ) {
 476             if( r->algo == algo )
 477                 return r->mdlen;
 478         }
 479     } while( !r && load_digest_module () );
 480     log_error("WARNING: no length for md algo %d\n", algo);
 481     return 0;
 482 }
 483
 484
 485 /* Hmmm: add a mode to enumerate the OIDs
 486  *      to make g10/sig-check.c more portable */
 487 const byte *
 488 md_asn_oid( int algo, size_t *asnlen, size_t *mdlen )
 489 {
 490     struct md_digest_list_s *r;
 491
 492     do {
 493         for(r = digest_list; r; r = r->next ) {
 494             if( r->algo == algo ) {
 495                 if( asnlen )
 496                     *asnlen = r->asnlen;
 497                 if( mdlen )
 498                     *mdlen = r->mdlen;
 499                 return r->asnoid;
 500             }
 501         }
 502     } while( !r && load_digest_module () );
 503     log_bug("no asn for md algo %d\n", algo);
 504     return NULL;
 505 }
 506
 507
 508 void
 509 md_start_debug( MD_HANDLE md, const char *suffix )
 510 {
 511     static int idx=0;
 512     char buf[25];
 513
 514     if( md->debug ) {
 515         log_debug("Oops: md debug already started\n");
 516         return;
 517     }
 518     idx++;
 519     sprintf(buf, "dbgmd-%05d" EXTSEP_S "%.10s", idx, suffix );
 520     md->debug = fopen(buf, "wb");
 521     if( !md->debug )
 522         log_debug("md debug: can't open %s\n", buf );
 523 }
 524
 525 void
 526 md_stop_debug( MD_HANDLE md )
 527 {
 528     if( md->debug ) {
 529         if( md->bufcount )
 530             md_write( md, NULL, 0 );
 531         fclose(md->debug);
 532         md->debug = NULL;
 533     }
 534 #ifdef HAVE_U64_TYPEDEF
 535     {  /* a kludge to pull in the __muldi3 for Solaris */
 536        volatile u32 a = (u32)(ulong)md;
 537        volatile u64 b = 42;
 538        volatile u64 c;
 539        c = a * b;
 540     }
 541 #endif
 542 }