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