external/bsd/libbind/dist/dst/hmac_link.c

   1 /*      $NetBSD$        */
   2
   3 #ifdef HMAC_MD5
   4 #ifndef LINT
   5 static 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
  64 typedef 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
  89 static int
  90 dst_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
 158 static int
 159 dst_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  */
 221 static int
 222 dst_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
 276 static int
 277 dst_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
 339 static int
 340 dst_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  */
 390 static int
 391 dst_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
 416 static int
 417 dst_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
 429 static void *
 430 dst_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
 445 static int
 446 dst_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  */
 457 int
 458 #ifdef  SUNW_LIBMD5
 459 dst_md5_hmac_init()
 460 #else
 461 dst_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
 485 int
 486 dst_hmac_md5_init(){
 487         return (0);
 488 }
 489 #endif
 490
 491 /*! \file */