/contrib/bind9/lib/isc/md5.c

  1/*
  2 * Copyright (C) 2004, 2005, 2007, 2009  Internet Systems Consortium, Inc. ("ISC")
  3 * Copyright (C) 2000, 2001  Internet Software Consortium.
  4 *
  5 * Permission to use, copy, modify, and/or distribute this software for any
  6 * purpose with or without fee is hereby granted, provided that the above
  7 * copyright notice and this permission notice appear in all copies.
  8 *
  9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
 10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 11 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
 12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 15 * PERFORMANCE OF THIS SOFTWARE.
 16 */
 17
 18/* $Id: md5.c,v 1.16 2009/02/06 23:47:42 tbox Exp $ */
 19
 20/*! \file
 21 * This code implements the MD5 message-digest algorithm.
 22 * The algorithm is due to Ron Rivest.  This code was
 23 * written by Colin Plumb in 1993, no copyright is claimed.
 24 * This code is in the public domain; do with it what you wish.
 25 *
 26 * Equivalent code is available from RSA Data Security, Inc.
 27 * This code has been tested against that, and is equivalent,
 28 * except that you don't need to include two pages of legalese
 29 * with every copy.
 30 *
 31 * To compute the message digest of a chunk of bytes, declare an
 32 * MD5Context structure, pass it to MD5Init, call MD5Update as
 33 * needed on buffers full of bytes, and then call MD5Final, which
 34 * will fill a supplied 16-byte array with the digest.
 35 */
 36
 37#include "config.h"
 38
 39#include <isc/assertions.h>
 40#include <isc/md5.h>
 41#include <isc/platform.h>
 42#include <isc/string.h>
 43#include <isc/types.h>
 44#include <isc/util.h>
 45
 46#ifdef ISC_PLATFORM_OPENSSLHASH
 47
 48void
 49isc_md5_init(isc_md5_t *ctx) {
 50	EVP_DigestInit(ctx, EVP_md5());
 51}
 52
 53void
 54isc_md5_invalidate(isc_md5_t *ctx) {
 55	EVP_MD_CTX_cleanup(ctx);
 56}
 57
 58void
 59isc_md5_update(isc_md5_t *ctx, const unsigned char *buf, unsigned int len) {
 60	EVP_DigestUpdate(ctx, (const void *) buf, (size_t) len);
 61}
 62
 63void
 64isc_md5_final(isc_md5_t *ctx, unsigned char *digest) {
 65	EVP_DigestFinal(ctx, digest, NULL);
 66}
 67
 68#else
 69
 70static void
 71byteSwap(isc_uint32_t *buf, unsigned words)
 72{
 73	unsigned char *p = (unsigned char *)buf;
 74
 75	do {
 76		*buf++ = (isc_uint32_t)((unsigned)p[3] << 8 | p[2]) << 16 |
 77			((unsigned)p[1] << 8 | p[0]);
 78		p += 4;
 79	} while (--words);
 80}
 81
 82/*!
 83 * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
 84 * initialization constants.
 85 */
 86void
 87isc_md5_init(isc_md5_t *ctx) {
 88	ctx->buf[0] = 0x67452301;
 89	ctx->buf[1] = 0xefcdab89;
 90	ctx->buf[2] = 0x98badcfe;
 91	ctx->buf[3] = 0x10325476;
 92
 93	ctx->bytes[0] = 0;
 94	ctx->bytes[1] = 0;
 95}
 96
 97void
 98isc_md5_invalidate(isc_md5_t *ctx) {
 99	memset(ctx, 0, sizeof(isc_md5_t));
100}
101
102/*@{*/
103/*! The four core functions - F1 is optimized somewhat */
104
105/* #define F1(x, y, z) (x & y | ~x & z) */
106#define F1(x, y, z) (z ^ (x & (y ^ z)))
107#define F2(x, y, z) F1(z, x, y)
108#define F3(x, y, z) (x ^ y ^ z)
109#define F4(x, y, z) (y ^ (x | ~z))
110/*@}*/
111
112/*! This is the central step in the MD5 algorithm. */
113#define MD5STEP(f,w,x,y,z,in,s) \
114	 (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
115
116/*!
117 * The core of the MD5 algorithm, this alters an existing MD5 hash to
118 * reflect the addition of 16 longwords of new data.  MD5Update blocks
119 * the data and converts bytes into longwords for this routine.
120 */
121static void
122transform(isc_uint32_t buf[4], isc_uint32_t const in[16]) {
123	register isc_uint32_t a, b, c, d;
124
125	a = buf[0];
126	b = buf[1];
127	c = buf[2];
128	d = buf[3];
129
130	MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
131	MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
132	MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
133	MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
134	MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
135	MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
136	MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
137	MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
138	MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
139	MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
140	MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
141	MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
142	MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
143	MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
144	MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
145	MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
146
147	MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
148	MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
149	MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
150	MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
151	MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
152	MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
153	MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
154	MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
155	MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
156	MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
157	MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
158	MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
159	MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
160	MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
161	MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
162	MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
163
164	MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
165	MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
166	MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
167	MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
168	MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
169	MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
170	MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
171	MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
172	MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
173	MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
174	MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
175	MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
176	MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
177	MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
178	MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
179	MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
180
181	MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
182	MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
183	MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
184	MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
185	MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
186	MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
187	MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
188	MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
189	MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
190	MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
191	MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
192	MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
193	MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
194	MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
195	MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
196	MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
197
198	buf[0] += a;
199	buf[1] += b;
200	buf[2] += c;
201	buf[3] += d;
202}
203
204/*!
205 * Update context to reflect the concatenation of another buffer full
206 * of bytes.
207 */
208void
209isc_md5_update(isc_md5_t *ctx, const unsigned char *buf, unsigned int len) {
210	isc_uint32_t t;
211
212	/* Update byte count */
213
214	t = ctx->bytes[0];
215	if ((ctx->bytes[0] = t + len) < t)
216		ctx->bytes[1]++;	/* Carry from low to high */
217
218	t = 64 - (t & 0x3f);	/* Space available in ctx->in (at least 1) */
219	if (t > len) {
220		memcpy((unsigned char *)ctx->in + 64 - t, buf, len);
221		return;
222	}
223	/* First chunk is an odd size */
224	memcpy((unsigned char *)ctx->in + 64 - t, buf, t);
225	byteSwap(ctx->in, 16);
226	transform(ctx->buf, ctx->in);
227	buf += t;
228	len -= t;
229
230	/* Process data in 64-byte chunks */
231	while (len >= 64) {
232		memcpy(ctx->in, buf, 64);
233		byteSwap(ctx->in, 16);
234		transform(ctx->buf, ctx->in);
235		buf += 64;
236		len -= 64;
237	}
238
239	/* Handle any remaining bytes of data. */
240	memcpy(ctx->in, buf, len);
241}
242
243/*!
244 * Final wrapup - pad to 64-byte boundary with the bit pattern
245 * 1 0* (64-bit count of bits processed, MSB-first)
246 */
247void
248isc_md5_final(isc_md5_t *ctx, unsigned char *digest) {
249	int count = ctx->bytes[0] & 0x3f;    /* Number of bytes in ctx->in */
250	unsigned char *p = (unsigned char *)ctx->in + count;
251
252	/* Set the first char of padding to 0x80.  There is always room. */
253	*p++ = 0x80;
254
255	/* Bytes of padding needed to make 56 bytes (-8..55) */
256	count = 56 - 1 - count;
257
258	if (count < 0) {	/* Padding forces an extra block */
259		memset(p, 0, count + 8);
260		byteSwap(ctx->in, 16);
261		transform(ctx->buf, ctx->in);
262		p = (unsigned char *)ctx->in;
263		count = 56;
264	}
265	memset(p, 0, count);
266	byteSwap(ctx->in, 14);
267
268	/* Append length in bits and transform */
269	ctx->in[14] = ctx->bytes[0] << 3;
270	ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;
271	transform(ctx->buf, ctx->in);
272
273	byteSwap(ctx->buf, 4);
274	memcpy(digest, ctx->buf, 16);
275	memset(ctx, 0, sizeof(isc_md5_t));	/* In case it's sensitive */
276}
277#endif