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