trunk/Gnupg/md.c

/* md.c - message digest wrapper
 *        Copyright (C) 2003, 2004 Timo Schulz
 *
 * This file is part of GPGLIB.
 *
 * GPGLIB is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * GPGLIB is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GPGLIB; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <windows.h>
#include <stdio.h>
#include <malloc.h>
#include <sys/types.h>

#include "openpgp.h"
#include "md.h"

struct gpgm_md_s {
    void * ctx;
    int algo;
    void (*write)( void *ctx, unsigned char *inbuf, size_t inlen );
};


gpg_md_t
gpg_md_open( int algo )
{
    gpg_md_t md;

    if (algo != MD_SHA1 && algo != MD_MD5 && algo != MD_RMD160 
        && algo != MD_SHA256 && algo != MD_SHA384 && algo != MD_SHA512)
        return NULL;
    md = calloc (1, sizeof * md);
    if( !md )
        return NULL;
    switch( algo ) {
    case MD_MD5:
        md->ctx = calloc( 1, sizeof (MD5_CONTEXT) );
        if( !md->ctx ) {
            free( md );
            return NULL;
        }
        md5_init( (MD5_CONTEXT *)md->ctx );
        md->write = md5_write;
        break;

    case MD_SHA1:
        md->ctx = calloc( 1, sizeof (SHA1_CONTEXT) );
        if( !md->ctx ) {
            free( md );
            return NULL;
        }
        sha1_init( (SHA1_CONTEXT *)md->ctx );
        md->write = sha1_write;
        break;

    case MD_RMD160:
        md->ctx = calloc( 1, sizeof (RMD160_CONTEXT) );
        if( !md->ctx ) {
            free( md );
            return NULL;
        }
        rmd160_init( (RMD160_CONTEXT *)md->ctx );
        md->write = rmd160_write;
        break;

    case MD_SHA256:
        md->ctx = calloc (1, sizeof (sha256_context));
        if (!md->ctx) {
            free (md);
            return NULL;
        }
        sha256_init ((sha256_context *)md->ctx);
        md->write = sha256_write;
        break;

    case MD_SHA384:
    case MD_SHA512:
        md->ctx = calloc (1, sizeof (sha512_context));
        if (!md->ctx) {
            free (md);
            return NULL;
        }
        sha512_init ((sha512_context *)md->ctx);
        md->write = sha512_write;
        break;

    default:
        free( md );
        return NULL;
    }
    md->algo = algo;
    return md;
}


void
gpg_md_close( gpg_md_t md )
{
    if( md ) {
        md->algo = 0;
        md->write = NULL;
        free( md->ctx ); md->ctx = NULL;
        free( md );
    }
}


void
gpg_md_final( gpg_md_t md )
{
    switch( md->algo ) {
    case MD_MD5   : md5_final( (MD5_CONTEXT *)md->ctx ); break;
    case MD_SHA1  : sha1_final( (SHA1_CONTEXT *) md->ctx ); break;
    case MD_RMD160: rmd160_final( (RMD160_CONTEXT *) md->ctx ); break;
    case MD_SHA256: sha256_final ((sha256_context *)md->ctx); break;
    case MD_SHA384:
    case MD_SHA512: sha512_final ((sha512_context *)md->ctx); break;
    }
}


const unsigned char *
gpg_md_read (gpg_md_t md)
{
    switch( md->algo ) {
    case MD_MD5   : return md5_read( (MD5_CONTEXT *)md->ctx ); break;
    case MD_SHA1  : return sha1_read( (SHA1_CONTEXT *)md->ctx ); break;
    case MD_RMD160: return rmd160_read( (RMD160_CONTEXT *)md->ctx ); break;
    case MD_SHA256: return sha256_read ((sha256_context *)md->ctx); break;
    case MD_SHA384:
    case MD_SHA512: return sha512_read ((sha512_context *)md->ctx); break;
    }
    return NULL;
}


void
gpg_md_putc( gpg_md_t md, int c )
{
    unsigned char buf[1];
    buf[0] = c & 0xff;
    md->write( md->ctx, buf, 1 );
}


size_t
_md_get_digest_len (gpg_md_t md)
{
    switch (md->algo) {
    case MD_MD5:
        return 16;
    case MD_SHA1:
    case MD_RMD160:
        return 20;
    case MD_SHA256:
        return 32;
    case MD_SHA384:
        return 48;
    case MD_SHA512:
        return 64;
    }
    return 0;
}


void
gpg_md_write( gpg_md_t md, unsigned char *inbuf, size_t len )
{
    if( md )
        md->write( md->ctx, inbuf, len );
}


int
gpg_md_hash_file( int mdalgo, const char *file, unsigned char *digest, size_t *nlen )
{
    gpg_md_t md;
    FILE * fp;
    char buf[8192];
    int n;

    md = gpg_md_open( mdalgo );
    if( !md )
        return -1;
    fp = fopen( file, "rb" );
    if( !fp ) {
        gpg_md_close( md );
        return -2;
    }
    while( !feof( fp ) ) {
        n = fread( buf, 1, sizeof buf-1, fp );
        if( !n )
            break;
        md->write( md->ctx, buf, n );
    }
    *nlen = _md_get_digest_len( md );
    gpg_md_final( md );
    memcpy( digest, gpg_md_read( md ), *nlen );
    fclose( fp );
    gpg_md_close( md );
    return 0;
}


static int
do_check_md (int algo, char * msg, const unsigned char * digest, size_t nlen)
{
    const unsigned char * tmp;
    int check=0;
    gpg_md_t md;

    md = gpg_md_open (algo);
    if (!md)
        return -1;
    gpg_md_write (md, msg, strlen (msg));
    gpg_md_final (md);
    tmp = gpg_md_read (md);
    check = memcmp (digest, tmp, nlen);
    gpg_md_close (md);

    return check;
}

struct {
    int algo;
    int dlen;
    char * msg;
    const unsigned char * md;
} md_test [] = {
    {MD_RMD160, 20, "abc", "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04\x4a\x8e\x98\xc6\xb0\x87\xf1\x5a\x0b\xfc"},
    {0, 0, NULL, NULL}
};


int
gpg_md_selftest (void)
{
    int i, rc=0;

    for (i=0; md_test[i].algo; i++) {
        rc = do_check_md (md_test[i].algo, md_test[i].msg, md_test[i].md,
                          md_test[i].dlen);
        if (rc)
            return rc;
    }
    return 0;
}
1	werner	46	/* md.c - message digest wrapper
2			* Copyright (C) 2003, 2004 Timo Schulz
3			*
4			* This file is part of GPGLIB.
5			*
6			* GPGLIB 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			* GPGLIB 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 GPGLIB; if not, write to the Free Software Foundation,
18			* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#ifdef HAVE_CONFIG_H
22			#include <config.h>
23			#endif
24
25			#include <windows.h>
26			#include <windows.h>
27			#include <stdio.h>
28			#include <malloc.h>
29			#include <sys/types.h>
30
31			#include "openpgp.h"
32			#include "md.h"
33
34			struct gpgm_md_s {
35			void * ctx;
36			int algo;
37			void (write)( void ctx, unsigned char *inbuf, size_t inlen );
38			};
39
40
41			gpg_md_t
42			gpg_md_open( int algo )
43			{
44			gpg_md_t md;
45
46			if (algo != MD_SHA1 && algo != MD_MD5 && algo != MD_RMD160
47			&& algo != MD_SHA256 && algo != MD_SHA384 && algo != MD_SHA512)
48			return NULL;
49			md = calloc (1, sizeof * md);
50			if( !md )
51			return NULL;
52			switch( algo ) {
53			case MD_MD5:
54			md->ctx = calloc( 1, sizeof (MD5_CONTEXT) );
55			if( !md->ctx ) {
56			free( md );
57			return NULL;
58			}
59			md5_init( (MD5_CONTEXT *)md->ctx );
60			md->write = md5_write;
61			break;
62
63			case MD_SHA1:
64			md->ctx = calloc( 1, sizeof (SHA1_CONTEXT) );
65			if( !md->ctx ) {
66			free( md );
67			return NULL;
68			}
69			sha1_init( (SHA1_CONTEXT *)md->ctx );
70			md->write = sha1_write;
71			break;
72
73			case MD_RMD160:
74			md->ctx = calloc( 1, sizeof (RMD160_CONTEXT) );
75			if( !md->ctx ) {
76			free( md );
77			return NULL;
78			}
79			rmd160_init( (RMD160_CONTEXT *)md->ctx );
80			md->write = rmd160_write;
81			break;
82
83			case MD_SHA256:
84			md->ctx = calloc (1, sizeof (sha256_context));
85			if (!md->ctx) {
86			free (md);
87			return NULL;
88			}
89			sha256_init ((sha256_context *)md->ctx);
90			md->write = sha256_write;
91			break;
92
93			case MD_SHA384:
94			case MD_SHA512:
95			md->ctx = calloc (1, sizeof (sha512_context));
96			if (!md->ctx) {
97			free (md);
98			return NULL;
99			}
100			sha512_init ((sha512_context *)md->ctx);
101			md->write = sha512_write;
102			break;
103
104			default:
105			free( md );
106			return NULL;
107			}
108			md->algo = algo;
109			return md;
110			}
111
112
113			void
114			gpg_md_close( gpg_md_t md )
115			{
116			if( md ) {
117			md->algo = 0;
118			md->write = NULL;
119			free( md->ctx ); md->ctx = NULL;
120			free( md );
121			}
122			}
123
124
125			void
126			gpg_md_final( gpg_md_t md )
127			{
128			switch( md->algo ) {
129			case MD_MD5 : md5_final( (MD5_CONTEXT *)md->ctx ); break;
130			case MD_SHA1 : sha1_final( (SHA1_CONTEXT *) md->ctx ); break;
131			case MD_RMD160: rmd160_final( (RMD160_CONTEXT *) md->ctx ); break;
132			case MD_SHA256: sha256_final ((sha256_context *)md->ctx); break;
133			case MD_SHA384:
134			case MD_SHA512: sha512_final ((sha512_context *)md->ctx); break;
135			}
136			}
137
138
139			const unsigned char *
140			gpg_md_read (gpg_md_t md)
141			{
142			switch( md->algo ) {
143			case MD_MD5 : return md5_read( (MD5_CONTEXT *)md->ctx ); break;
144			case MD_SHA1 : return sha1_read( (SHA1_CONTEXT *)md->ctx ); break;
145			case MD_RMD160: return rmd160_read( (RMD160_CONTEXT *)md->ctx ); break;
146			case MD_SHA256: return sha256_read ((sha256_context *)md->ctx); break;
147			case MD_SHA384:
148			case MD_SHA512: return sha512_read ((sha512_context *)md->ctx); break;
149			}
150			return NULL;
151			}
152
153
154			void
155			gpg_md_putc( gpg_md_t md, int c )
156			{
157			unsigned char buf[1];
158			buf[0] = c & 0xff;
159			md->write( md->ctx, buf, 1 );
160			}
161
162
163			size_t
164			_md_get_digest_len (gpg_md_t md)
165			{
166			switch (md->algo) {
167			case MD_MD5:
168			return 16;
169			case MD_SHA1:
170			case MD_RMD160:
171			return 20;
172			case MD_SHA256:
173			return 32;
174			case MD_SHA384:
175			return 48;
176			case MD_SHA512:
177			return 64;
178			}
179			return 0;
180			}
181
182
183			void
184			gpg_md_write( gpg_md_t md, unsigned char *inbuf, size_t len )
185			{
186			if( md )
187			md->write( md->ctx, inbuf, len );
188			}
189
190
191			int
192			gpg_md_hash_file( int mdalgo, const char file, unsigned char digest, size_t *nlen )
193			{
194			gpg_md_t md;
195			FILE * fp;
196			char buf[8192];
197			int n;
198
199			md = gpg_md_open( mdalgo );
200			if( !md )
201			return -1;
202			fp = fopen( file, "rb" );
203			if( !fp ) {
204			gpg_md_close( md );
205			return -2;
206			}
207			while( !feof( fp ) ) {
208			n = fread( buf, 1, sizeof buf-1, fp );
209			if( !n )
210			break;
211			md->write( md->ctx, buf, n );
212			}
213			*nlen = _md_get_digest_len( md );
214			gpg_md_final( md );
215			memcpy( digest, gpg_md_read( md ), *nlen );
216			fclose( fp );
217			gpg_md_close( md );
218			return 0;
219			}
220
221
222			static int
223			do_check_md (int algo, char * msg, const unsigned char * digest, size_t nlen)
224			{
225			const unsigned char * tmp;
226			int check=0;
227			gpg_md_t md;
228
229			md = gpg_md_open (algo);
230			if (!md)
231			return -1;
232			gpg_md_write (md, msg, strlen (msg));
233			gpg_md_final (md);
234			tmp = gpg_md_read (md);
235			check = memcmp (digest, tmp, nlen);
236			gpg_md_close (md);
237
238			return check;
239			}
240
241			struct {
242			int algo;
243			int dlen;
244			char * msg;
245			const unsigned char * md;
246			} md_test [] = {
247			{MD_RMD160, 20, "abc", "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04\x4a\x8e\x98\xc6\xb0\x87\xf1\x5a\x0b\xfc"},
248			{0, 0, NULL, NULL}
249			};
250
251
252			int
253			gpg_md_selftest (void)
254			{
255			int i, rc=0;
256
257			for (i=0; md_test[i].algo; i++) {
258			rc = do_check_md (md_test[i].algo, md_test[i].msg, md_test[i].md,
259			md_test[i].dlen);
260			if (rc)
261			return rc;
262			}
263			return 0;
264			}