hmac_link.c revision 1.1.1.1 
1/*	$NetBSD: hmac_link.c,v 1.1.1.1 2009/04/12 15:33:32 christos Exp $	*/
2
3#ifdef HMAC_MD5
4#ifndef LINT
5static const char rcsid[] = "Header: /proj/cvs/prod/libbind/dst/hmac_link.c,v 1.8 2007/09/24 17:18:25 each Exp";
6#endif
7/*
8 * Portions Copyright (c) 1995-1998 by Trusted Information Systems, Inc.
9 *
10 * Permission to use, copy modify, and distribute this software for any
11 * purpose with or without fee is hereby granted, provided that the above
12 * copyright notice and this permission notice appear in all copies.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS" AND TRUSTED INFORMATION SYSTEMS
15 * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL
17 * TRUSTED INFORMATION SYSTEMS BE LIABLE FOR ANY SPECIAL, DIRECT,
18 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
19 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
20 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
21 * WITH THE USE OR PERFORMANCE OF THE SOFTWARE.
22 */
23
24/*%
25 * This file contains an implementation of the HMAC-MD5 algorithm.
26 */
27#include "port_before.h"
28
29#include <stdio.h>
30#include <unistd.h>
31#include <stdlib.h>
32#include <string.h>
33#include <memory.h>
34#include <sys/param.h>
35#include <sys/time.h>
36#include <netinet/in.h>
37#include <arpa/nameser.h>
38#include <resolv.h>
39
40#include "dst_internal.h"
41
42#ifdef USE_MD5
43# ifndef HAVE_MD5
44#  include "md5.h"
45# else
46#  ifdef SOLARIS2
47#   include <sys/md5.h>
48#  endif
49# endif
50# ifndef _MD5_H_
51#  define _MD5_H_ 1	/*%< make sure we do not include rsaref md5.h file */
52# endif
53#endif
54
55#include "port_after.h"
56
57
58#define HMAC_LEN	64
59#define HMAC_IPAD	0x36
60#define HMAC_OPAD	0x5c
61#define MD5_LEN		16
62
63
64typedef struct hmackey {
65	u_char hk_ipad[64], hk_opad[64];
66} HMAC_Key;
67
68
69/**************************************************************************
70 * dst_hmac_md5_sign
71 *     Call HMAC signing functions to sign a block of data.
72 *     There are three steps to signing, INIT (initialize structures),
73 *     UPDATE (hash (more) data), FINAL (generate a signature).  This
74 *     routine performs one or more of these steps.
75 * Parameters
76 *     mode	SIG_MODE_INIT, SIG_MODE_UPDATE and/or SIG_MODE_FINAL.
77 *     priv_key    key to use for signing.
78 *     context   the context to be used in this digest
79 *     data	data to be signed.
80 *     len	 length in bytes of data.
81 *     signature   location to store signature.
82 *     sig_len     size of the signature location
83 * returns
84 *	N  Success on SIG_MODE_FINAL = returns signature length in bytes
85 *	0  Success on SIG_MODE_INIT  and UPDATE
86 *	 <0  Failure
87 */
88
89static int
90dst_hmac_md5_sign(const int mode, DST_KEY *d_key, void **context,
91		  const u_char *data, const int len,
92		  u_char *signature, const int sig_len)
93{
94	HMAC_Key *key;
95	int sign_len = 0;
96	MD5_CTX *ctx = NULL;
97
98	if (d_key == NULL || d_key->dk_KEY_struct == NULL)
99		return (-1);
100
101	if (mode & SIG_MODE_INIT)
102		ctx = (MD5_CTX *) malloc(sizeof(*ctx));
103	else if (context)
104		ctx = (MD5_CTX *) *context;
105	if (ctx == NULL)
106		return (-1);
107
108	key = (HMAC_Key *) d_key->dk_KEY_struct;
109
110	if (mode & SIG_MODE_INIT) {
111		MD5Init(ctx);
112		MD5Update(ctx, key->hk_ipad, HMAC_LEN);
113	}
114
115	if ((mode & SIG_MODE_UPDATE) && (data && len > 0))
116		MD5Update(ctx, data, len);
117
118	if (mode & SIG_MODE_FINAL) {
119		if (signature == NULL || sig_len < MD5_LEN)
120			return (SIGN_FINAL_FAILURE);
121		MD5Final(signature, ctx);
122
123		/* perform outer MD5 */
124		MD5Init(ctx);
125		MD5Update(ctx, key->hk_opad, HMAC_LEN);
126		MD5Update(ctx, signature, MD5_LEN);
127		MD5Final(signature, ctx);
128		sign_len = MD5_LEN;
129		SAFE_FREE(ctx);
130	}
131	else {
132		if (context == NULL)
133			return (-1);
134		*context = (void *) ctx;
135	}
136	return (sign_len);
137}
138
139
140/**************************************************************************
141 * dst_hmac_md5_verify()
142 *     Calls HMAC verification routines.  There are three steps to
143 *     verification, INIT (initialize structures), UPDATE (hash (more) data),
144 *     FINAL (generate a signature).  This routine performs one or more of
145 *     these steps.
146 * Parameters
147 *     mode	SIG_MODE_INIT, SIG_MODE_UPDATE and/or SIG_MODE_FINAL.
148 *     dkey	key to use for verify.
149 *     data	data signed.
150 *     len	 length in bytes of data.
151 *     signature   signature.
152 *     sig_len     length in bytes of signature.
153 * returns
154 *     0  Success
155 *    <0  Failure
156 */
157
158static int
159dst_hmac_md5_verify(const int mode, DST_KEY *d_key, void **context,
160		const u_char *data, const int len,
161		const u_char *signature, const int sig_len)
162{
163	HMAC_Key *key;
164	MD5_CTX *ctx = NULL;
165
166	if (d_key == NULL || d_key->dk_KEY_struct == NULL)
167		return (-1);
168
169	if (mode & SIG_MODE_INIT)
170		ctx = (MD5_CTX *) malloc(sizeof(*ctx));
171	else if (context)
172		ctx = (MD5_CTX *) *context;
173	if (ctx == NULL)
174		return (-1);
175
176	key = (HMAC_Key *) d_key->dk_KEY_struct;
177	if (mode & SIG_MODE_INIT) {
178		MD5Init(ctx);
179		MD5Update(ctx, key->hk_ipad, HMAC_LEN);
180	}
181	if ((mode & SIG_MODE_UPDATE) && (data && len > 0))
182		MD5Update(ctx, data, len);
183
184	if (mode & SIG_MODE_FINAL) {
185		u_char digest[MD5_LEN];
186		if (signature == NULL || key == NULL || sig_len != MD5_LEN)
187			return (VERIFY_FINAL_FAILURE);
188		MD5Final(digest, ctx);
189
190		/* perform outer MD5 */
191		MD5Init(ctx);
192		MD5Update(ctx, key->hk_opad, HMAC_LEN);
193		MD5Update(ctx, digest, MD5_LEN);
194		MD5Final(digest, ctx);
195
196		SAFE_FREE(ctx);
197		if (memcmp(digest, signature, MD5_LEN) != 0)
198			return (VERIFY_FINAL_FAILURE);
199	}
200	else {
201		if (context == NULL)
202			return (-1);
203		*context = (void *) ctx;
204	}
205	return (0);
206}
207
208
209/**************************************************************************
210 * dst_buffer_to_hmac_md5
211 *     Converts key from raw data to an HMAC Key
212 *     This function gets in a pointer to the data
213 * Parameters
214 *     hkey	the HMAC key to be filled in
215 *     key	the key in raw format
216 *     keylen	the length of the key
217 * Return
218 *	0	Success
219 *	<0	Failure
220 */
221static int
222dst_buffer_to_hmac_md5(DST_KEY *dkey, const u_char *key, const int keylen)
223{
224	int i;
225	HMAC_Key *hkey = NULL;
226	MD5_CTX ctx;
227	int local_keylen = keylen;
228	u_char tk[MD5_LEN];
229
230	if (dkey == NULL || key == NULL || keylen < 0)
231		return (-1);
232
233	if ((hkey = (HMAC_Key *) malloc(sizeof(HMAC_Key))) == NULL)
234		  return (-2);
235
236	memset(hkey->hk_ipad, 0, sizeof(hkey->hk_ipad));
237	memset(hkey->hk_opad, 0, sizeof(hkey->hk_opad));
238
239	/* if key is longer than HMAC_LEN bytes reset it to key=MD5(key) */
240	if (keylen > HMAC_LEN) {
241		MD5Init(&ctx);
242		MD5Update(&ctx, key, keylen);
243		MD5Final(tk, &ctx);
244		memset((void *) &ctx, 0, sizeof(ctx));
245		key = tk;
246		local_keylen = MD5_LEN;
247	}
248	/* start out by storing key in pads */
249	memcpy(hkey->hk_ipad, key, local_keylen);
250	memcpy(hkey->hk_opad, key, local_keylen);
251
252	/* XOR key with hk_ipad and opad values */
253	for (i = 0; i < HMAC_LEN; i++) {
254		hkey->hk_ipad[i] ^= HMAC_IPAD;
255		hkey->hk_opad[i] ^= HMAC_OPAD;
256	}
257	dkey->dk_key_size = local_keylen;
258	dkey->dk_KEY_struct = (void *) hkey;
259	return (1);
260}
261
262
263/**************************************************************************
264 *  dst_hmac_md5_key_to_file_format
265 *	Encodes an HMAC Key into the portable file format.
266 *  Parameters
267 *	hkey      HMAC KEY structure
268 *	buff      output buffer
269 *	buff_len  size of output buffer
270 *  Return
271 *	0  Failure - null input hkey
272 *     -1  Failure - not enough space in output area
273 *	N  Success - Length of data returned in buff
274 */
275
276static int
277dst_hmac_md5_key_to_file_format(const DST_KEY *dkey, char *buff,
278			        const int buff_len)
279{
280	char *bp;
281	int len, i, key_len;
282	u_char key[HMAC_LEN];
283	HMAC_Key *hkey;
284
285	if (dkey == NULL || dkey->dk_KEY_struct == NULL)
286		return (0);
287	/*
288	 * Using snprintf() would be so much simpler here.
289	 */
290	if (buff == NULL ||
291	    buff_len <= (int)(strlen(key_file_fmt_str) +
292			      strlen(KEY_FILE_FORMAT) + 4))
293		return (-1);	/*%< no OR not enough space in output area */
294	hkey = (HMAC_Key *) dkey->dk_KEY_struct;
295	memset(buff, 0, buff_len);	/*%< just in case */
296	/* write file header */
297	sprintf(buff, key_file_fmt_str, KEY_FILE_FORMAT, KEY_HMAC_MD5, "HMAC");
298
299	bp = buff + strlen(buff);
300
301	memset(key, 0, HMAC_LEN);
302	for (i = 0; i < HMAC_LEN; i++)
303		key[i] = hkey->hk_ipad[i] ^ HMAC_IPAD;
304	for (i = HMAC_LEN - 1; i >= 0; i--)
305		if (key[i] != 0)
306			break;
307	key_len = i + 1;
308
309	if (buff_len - (bp - buff) < 6)
310		return (-1);
311	strcat(bp, "Key: ");
312	bp += strlen("Key: ");
313
314	len = b64_ntop(key, key_len, bp, buff_len - (bp - buff));
315	if (len < 0)
316		return (-1);
317	bp += len;
318	if (buff_len - (bp - buff) < 2)
319		return (-1);
320	*(bp++) = '\n';
321	*bp = '\0';
322
323	return (bp - buff);
324}
325
326
327/**************************************************************************
328 * dst_hmac_md5_key_from_file_format
329 *     Converts contents of a key file into an HMAC key.
330 * Parameters
331 *     hkey    structure to put key into
332 *     buff       buffer containing the encoded key
333 *     buff_len   the length of the buffer
334 * Return
335 *     n >= 0 Foot print of the key converted
336 *     n <  0 Error in conversion
337 */
338
339static int
340dst_hmac_md5_key_from_file_format(DST_KEY *dkey, const char *buff,
341			      const int buff_len)
342{
343	const char *p = buff, *eol;
344	u_char key[HMAC_LEN+1];	/* b64_pton needs more than 64 bytes do decode
345				 * it should probably be fixed rather than doing
346				 * this
347				 */
348	u_char *tmp;
349	int key_len, len;
350
351	if (dkey == NULL)
352		return (-2);
353	if (buff == NULL || buff_len < 0)
354		return (-1);
355
356	memset(key, 0, sizeof(key));
357
358	if (!dst_s_verify_str(&p, "Key: "))
359		return (-3);
360
361	eol = strchr(p, '\n');
362	if (eol == NULL)
363		return (-4);
364	len = eol - p;
365	tmp = malloc(len + 2);
366	if (tmp == NULL)
367		return (-5);
368	memcpy(tmp, p, len);
369	*(tmp + len) = 0x0;
370	key_len = b64_pton((char *)tmp, key, HMAC_LEN+1);	/*%< see above */
371	SAFE_FREE2(tmp, len + 2);
372
373	if (dst_buffer_to_hmac_md5(dkey, key, key_len) < 0) {
374		return (-6);
375	}
376	return (0);
377}
378
379/*%
380 * dst_hmac_md5_to_dns_key()
381 *         function to extract hmac key from DST_KEY structure
382 * intput:
383 *      in_key:  HMAC-MD5 key
384 * output:
385 *	out_str: buffer to write ot
386 *      out_len: size of output buffer
387 * returns:
388 *      number of bytes written to output buffer
389 */
390static int
391dst_hmac_md5_to_dns_key(const DST_KEY *in_key, u_char *out_str,
392			const int out_len)
393{
394
395	HMAC_Key *hkey;
396	int i;
397
398	if (in_key == NULL || in_key->dk_KEY_struct == NULL ||
399	    out_len <= in_key->dk_key_size || out_str == NULL)
400		return (-1);
401
402	hkey = (HMAC_Key *) in_key->dk_KEY_struct;
403	for (i = 0; i < in_key->dk_key_size; i++)
404		out_str[i] = hkey->hk_ipad[i] ^ HMAC_IPAD;
405	return (i);
406}
407
408/**************************************************************************
409 *  dst_hmac_md5_compare_keys
410 *	Compare two keys for equality.
411 *  Return
412 *	0	  The keys are equal
413 *	NON-ZERO   The keys are not equal
414 */
415
416static int
417dst_hmac_md5_compare_keys(const DST_KEY *key1, const DST_KEY *key2)
418{
419	HMAC_Key *hkey1 = (HMAC_Key *) key1->dk_KEY_struct;
420	HMAC_Key *hkey2 = (HMAC_Key *) key2->dk_KEY_struct;
421	return memcmp(hkey1->hk_ipad, hkey2->hk_ipad, HMAC_LEN);
422}
423
424/**************************************************************************
425 * dst_hmac_md5_free_key_structure
426 *     Frees all (none) dynamically allocated structures in hkey
427 */
428
429static void *
430dst_hmac_md5_free_key_structure(void *key)
431{
432	HMAC_Key *hkey = key;
433	SAFE_FREE(hkey);
434	return (NULL);
435}
436
437
438/***************************************************************************
439 * dst_hmac_md5_generate_key
440 *     Creates a HMAC key of size size with a maximum size of 63 bytes
441 *     generating a HMAC key larger than 63 bytes makes no sense as that key
442 *     is digested before use.
443 */
444
445static int
446dst_hmac_md5_generate_key(DST_KEY *key, const int nothing)
447{
448	(void)key;
449	(void)nothing;
450	return (-1);
451}
452
453/*%
454 * dst_hmac_md5_init()  Function to answer set up function pointers for HMAC
455 *	   related functions
456 */
457int
458#ifdef	SUNW_LIBMD5
459dst_md5_hmac_init()
460#else
461dst_hmac_md5_init()
462#endif
463{
464	if (dst_t_func[KEY_HMAC_MD5] != NULL)
465		return (1);
466	dst_t_func[KEY_HMAC_MD5] = malloc(sizeof(struct dst_func));
467	if (dst_t_func[KEY_HMAC_MD5] == NULL)
468		return (0);
469	memset(dst_t_func[KEY_HMAC_MD5], 0, sizeof(struct dst_func));
470	dst_t_func[KEY_HMAC_MD5]->sign = dst_hmac_md5_sign;
471	dst_t_func[KEY_HMAC_MD5]->verify = dst_hmac_md5_verify;
472	dst_t_func[KEY_HMAC_MD5]->compare = dst_hmac_md5_compare_keys;
473	dst_t_func[KEY_HMAC_MD5]->generate = dst_hmac_md5_generate_key;
474	dst_t_func[KEY_HMAC_MD5]->destroy = dst_hmac_md5_free_key_structure;
475	dst_t_func[KEY_HMAC_MD5]->to_dns_key = dst_hmac_md5_to_dns_key;
476	dst_t_func[KEY_HMAC_MD5]->from_dns_key = dst_buffer_to_hmac_md5;
477	dst_t_func[KEY_HMAC_MD5]->to_file_fmt = dst_hmac_md5_key_to_file_format;
478	dst_t_func[KEY_HMAC_MD5]->from_file_fmt = dst_hmac_md5_key_from_file_format;
479	return (1);
480}
481
482#else
483#define	dst_hmac_md5_init	__dst_hmac_md5_init
484
485int
486dst_hmac_md5_init(){
487	return (0);
488}
489#endif
490
491/*! \file */
492