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
 */

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