* main.h, keylist.c (print_subpackets_colon): Make a public function.
[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_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 }