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