1 /* 2 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 3 * Use is subject to license terms. 4 */ 5 6 #pragma ident "%Z%%M% %I% %E% SMI" 7 8 #ifdef HMAC_MD5 9 #ifndef LINT 10 static const char rcsid[] = "$Header: /proj/cvs/isc/bind8/src/lib/dst/hmac_link.c,v 1.9 2001/05/29 05:48:10 marka Exp $"; 11 #endif 12 /* 13 * Portions Copyright (c) 1995-1998 by Trusted Information Systems, Inc. 14 * 15 * Permission to use, copy modify, and distribute this software for any 16 * purpose with or without fee is hereby granted, provided that the above 17 * copyright notice and this permission notice appear in all copies. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS" AND TRUSTED INFORMATION SYSTEMS 20 * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL 22 * TRUSTED INFORMATION SYSTEMS BE LIABLE FOR ANY SPECIAL, DIRECT, 23 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING 24 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, 25 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 26 * WITH THE USE OR PERFORMANCE OF THE SOFTWARE. 27 */ 28 29 /* 30 * This file contains an implementation of the HMAC-MD5 algorithm. 31 */ 32 #include "port_before.h" 33 34 #include <stdio.h> 35 #include <unistd.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <memory.h> 39 #include <sys/param.h> 40 #include <sys/time.h> 41 #include <netinet/in.h> 42 #include <arpa/nameser.h> 43 #include <resolv.h> 44 45 #include "dst_internal.h" 46 #ifdef USE_MD5 47 #ifndef SUNW_LIBMD5 48 # include "md5.h" 49 #else 50 #include <sys/md5.h> 51 #endif 52 # ifndef _MD5_H_ 53 # define _MD5_H_ 1 /* make sure we do not include rsaref md5.h file */ 54 # endif 55 #endif 56 57 #include "port_after.h" 58 59 60 #define HMAC_LEN 64 61 #define HMAC_IPAD 0x36 62 #define HMAC_OPAD 0x5c 63 #define MD5_LEN 16 64 65 66 typedef struct hmackey { 67 u_char hk_ipad[64], hk_opad[64]; 68 } HMAC_Key; 69 70 71 /************************************************************************** 72 * dst_hmac_md5_sign 73 * Call HMAC signing functions to sign a block of data. 74 * There are three steps to signing, INIT (initialize structures), 75 * UPDATE (hash (more) data), FINAL (generate a signature). This 76 * routine performs one or more of these steps. 77 * Parameters 78 * mode SIG_MODE_INIT, SIG_MODE_UPDATE and/or SIG_MODE_FINAL. 79 * priv_key key to use for signing. 80 * context the context to be used in this digest 81 * data data to be signed. 82 * len length in bytes of data. 83 * signature location to store signature. 84 * sig_len size of the signature location 85 * returns 86 * N Success on SIG_MODE_FINAL = returns signature length in bytes 87 * 0 Success on SIG_MODE_INIT and UPDATE 88 * <0 Failure 89 */ 90 91 static int 92 dst_hmac_md5_sign(const int mode, DST_KEY *d_key, void **context, 93 const u_char *data, const int len, 94 u_char *signature, const int sig_len) 95 { 96 HMAC_Key *key; 97 int sign_len = 0; 98 MD5_CTX *ctx = NULL; 99 100 if (mode & SIG_MODE_INIT) 101 ctx = (MD5_CTX *) malloc(sizeof(*ctx)); 102 else if (context) 103 ctx = (MD5_CTX *) *context; 104 if (ctx == NULL) 105 return (-1); 106 107 if (d_key == NULL || d_key->dk_KEY_struct == NULL) 108 return (-1); 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 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 (mode & SIG_MODE_INIT) 168 ctx = (MD5_CTX *) malloc(sizeof(*ctx)); 169 else if (context) 170 ctx = (MD5_CTX *) *context; 171 if (ctx == NULL) 172 return (-1); 173 174 if (d_key == NULL || d_key->dk_KEY_struct == 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 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 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 u_char tk[MD5_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 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, b_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 if (buff == NULL || buff_len <= (int) strlen(key_file_fmt_str)) 289 return (-1); /* no OR not enough space in output area */ 290 291 hkey = (HMAC_Key *) dkey->dk_KEY_struct; 292 memset(buff, 0, buff_len); /* just in case */ 293 /* write file header */ 294 sprintf(buff, key_file_fmt_str, KEY_FILE_FORMAT, KEY_HMAC_MD5, "HMAC"); 295 296 bp = (char *) strchr(buff, '\0'); 297 b_len = buff_len - (bp - buff); 298 299 memset(key, 0, HMAC_LEN); 300 for (i = 0; i < HMAC_LEN; i++) 301 key[i] = hkey->hk_ipad[i] ^ HMAC_IPAD; 302 for (i = HMAC_LEN - 1; i >= 0; i--) 303 if (key[i] != 0) 304 break; 305 key_len = i + 1; 306 307 strcat(bp, "Key: "); 308 bp += strlen("Key: "); 309 b_len = buff_len - (bp - buff); 310 311 len = b64_ntop(key, key_len, bp, b_len); 312 if (len < 0) 313 return (-1); 314 bp += len; 315 *(bp++) = '\n'; 316 *bp = '\0'; 317 b_len = buff_len - (bp - buff); 318 319 return (buff_len - b_len); 320 } 321 322 323 /************************************************************************** 324 * dst_hmac_md5_key_from_file_format 325 * Converts contents of a key file into an HMAC key. 326 * Parameters 327 * hkey structure to put key into 328 * buff buffer containing the encoded key 329 * buff_len the length of the buffer 330 * Return 331 * n >= 0 Foot print of the key converted 332 * n < 0 Error in conversion 333 */ 334 335 static int 336 dst_hmac_md5_key_from_file_format(DST_KEY *dkey, const char *buff, 337 const int buff_len) 338 { 339 const char *p = buff, *eol; 340 u_char key[HMAC_LEN+1]; /* b64_pton needs more than 64 bytes do decode 341 * it should probably be fixed rather than doing 342 * this 343 */ 344 u_char *tmp; 345 int key_len, len; 346 347 if (dkey == NULL) 348 return (-2); 349 if (buff == NULL || buff_len < 0) 350 return (-1); 351 352 memset(key, 0, sizeof(key)); 353 354 if (!dst_s_verify_str(&p, "Key: ")) 355 return (-3); 356 357 eol = strchr(p, '\n'); 358 if (eol == NULL) 359 return (-4); 360 len = eol - p; 361 tmp = malloc(len + 2); 362 memcpy(tmp, p, len); 363 *(tmp + len) = 0x0; 364 key_len = b64_pton((char *)tmp, key, HMAC_LEN+1); /* see above */ 365 SAFE_FREE2(tmp, len + 2); 366 367 if (dst_buffer_to_hmac_md5(dkey, key, key_len) < 0) { 368 return (-6); 369 } 370 return (0); 371 } 372 373 /* 374 * dst_hmac_md5_to_dns_key() 375 * function to extract hmac key from DST_KEY structure 376 * intput: 377 * in_key: HMAC-MD5 key 378 * output: 379 * out_str: buffer to write ot 380 * out_len: size of output buffer 381 * returns: 382 * number of bytes written to output buffer 383 */ 384 static int 385 dst_hmac_md5_to_dns_key(const DST_KEY *in_key, u_char *out_str, 386 const int out_len) 387 { 388 389 HMAC_Key *hkey; 390 int i; 391 392 if (in_key == NULL || in_key->dk_KEY_struct == NULL || 393 out_len <= in_key->dk_key_size || out_str == NULL) 394 return (-1); 395 396 hkey = (HMAC_Key *) in_key->dk_KEY_struct; 397 for (i = 0; i < in_key->dk_key_size; i++) 398 out_str[i] = hkey->hk_ipad[i] ^ HMAC_IPAD; 399 return (i); 400 } 401 402 /************************************************************************** 403 * dst_hmac_md5_compare_keys 404 * Compare two keys for equality. 405 * Return 406 * 0 The keys are equal 407 * NON-ZERO The keys are not equal 408 */ 409 410 static int 411 dst_hmac_md5_compare_keys(const DST_KEY *key1, const DST_KEY *key2) 412 { 413 HMAC_Key *hkey1 = (HMAC_Key *) key1->dk_KEY_struct; 414 HMAC_Key *hkey2 = (HMAC_Key *) key2->dk_KEY_struct; 415 return memcmp(hkey1->hk_ipad, hkey2->hk_ipad, HMAC_LEN); 416 } 417 418 /************************************************************************** 419 * dst_hmac_md5_free_key_structure 420 * Frees all (none) dynamically allocated structures in hkey 421 */ 422 423 static void * 424 dst_hmac_md5_free_key_structure(void *key) 425 { 426 HMAC_Key *hkey = key; 427 SAFE_FREE(hkey); 428 return (NULL); 429 } 430 431 432 /*************************************************************************** 433 * dst_hmac_md5_generate_key 434 * Creates a HMAC key of size size with a maximum size of 63 bytes 435 * generating a HMAC key larger than 63 bytes makes no sense as that key 436 * is digested before use. 437 */ 438 439 static int 440 dst_hmac_md5_generate_key(DST_KEY *key, const int nothing) 441 { 442 u_char *buff; 443 int i, n, size; 444 445 i = nothing; 446 447 if (key == NULL || key->dk_alg != KEY_HMAC_MD5) 448 return (0); 449 size = (key->dk_key_size + 7) / 8; /* convert to bytes */ 450 if (size <= 0) 451 return(0); 452 453 i = size > 64 ? 64 : size; 454 buff = malloc(i+8); 455 456 n = dst_random(DST_RAND_SEMI, i, buff); 457 n += dst_random(DST_RAND_KEY, i, buff); 458 if (n <= i) { /* failed getting anything */ 459 SAFE_FREE2(buff, i); 460 return (-1); 461 } 462 n = dst_buffer_to_hmac_md5(key, buff, i); 463 SAFE_FREE2(buff, i); 464 if (n <= 0) 465 return (n); 466 return (1); 467 } 468 469 /* 470 * dst_hmac_md5_init() Function to answer set up function pointers for HMAC 471 * related functions 472 */ 473 int 474 #ifdef ORIGINAL_ISC_CODE 475 dst_hmac_md5_init() 476 #else 477 dst_md5_hmac_init() 478 #endif 479 { 480 if (dst_t_func[KEY_HMAC_MD5] != NULL) 481 return (1); 482 dst_t_func[KEY_HMAC_MD5] = malloc(sizeof(struct dst_func)); 483 if (dst_t_func[KEY_HMAC_MD5] == NULL) 484 return (0); 485 memset(dst_t_func[KEY_HMAC_MD5], 0, sizeof(struct dst_func)); 486 dst_t_func[KEY_HMAC_MD5]->sign = dst_hmac_md5_sign; 487 dst_t_func[KEY_HMAC_MD5]->verify = dst_hmac_md5_verify; 488 dst_t_func[KEY_HMAC_MD5]->compare = dst_hmac_md5_compare_keys; 489 dst_t_func[KEY_HMAC_MD5]->generate = dst_hmac_md5_generate_key; 490 dst_t_func[KEY_HMAC_MD5]->destroy = dst_hmac_md5_free_key_structure; 491 dst_t_func[KEY_HMAC_MD5]->to_dns_key = dst_hmac_md5_to_dns_key; 492 dst_t_func[KEY_HMAC_MD5]->from_dns_key = dst_buffer_to_hmac_md5; 493 dst_t_func[KEY_HMAC_MD5]->to_file_fmt = dst_hmac_md5_key_to_file_format; 494 dst_t_func[KEY_HMAC_MD5]->from_file_fmt = dst_hmac_md5_key_from_file_format; 495 return (1); 496 } 497 498 #else 499 int 500 dst_hmac_md5_init(){ 501 return (0); 502 } 503 #endif 504 505 506 507 508 509 510 511