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