crypto/external/bsd/heimdal/dist/lib/hcrypto/hmac.c

   1 /*      $NetBSD: hmac.c,v 1.1.1.1 2011/04/13 18:14:50 elric Exp $       */
   2
   3 /*
   4  * Copyright (c) 2006 - 2007 Kungliga Tekniska Högskolan
   5  * (Royal Institute of Technology, Stockholm, Sweden).
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * 3. Neither the name of the Institute nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <sys/types.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <hmac.h>
  41
  42 void
  43 HMAC_CTX_init(HMAC_CTX *ctx)
  44 {
  45     memset(ctx, 0, sizeof(*ctx));
  46 }
  47
  48 void
  49 HMAC_CTX_cleanup(HMAC_CTX *ctx)
  50 {
  51     if (ctx->buf) {
  52         memset(ctx->buf, 0, ctx->key_length);
  53         free(ctx->buf);
  54         ctx->buf = NULL;
  55     }
  56     if (ctx->opad) {
  57         memset(ctx->opad, 0, EVP_MD_block_size(ctx->md));
  58         free(ctx->opad);
  59         ctx->opad = NULL;
  60     }
  61     if (ctx->ipad) {
  62         memset(ctx->ipad, 0, EVP_MD_block_size(ctx->md));
  63         free(ctx->ipad);
  64         ctx->ipad = NULL;
  65     }
  66     if (ctx->ctx) {
  67         EVP_MD_CTX_destroy(ctx->ctx);
  68         ctx->ctx = NULL;
  69     }
  70 }
  71
  72 size_t
  73 HMAC_size(const HMAC_CTX *ctx)
  74 {
  75     return EVP_MD_size(ctx->md);
  76 }
  77
  78 void
  79 HMAC_Init_ex(HMAC_CTX *ctx,
  80              const void *key,
  81              size_t keylen,
  82              const EVP_MD *md,
  83              ENGINE *engine)
  84 {
  85     unsigned char *p;
  86     size_t i;
  87
  88     if (ctx->md != md) {
  89         ctx->md = md;
  90         if (ctx->buf) {
  91             memset(ctx->buf, 0, ctx->key_length);
  92             free (ctx->buf);
  93         }
  94         ctx->key_length = EVP_MD_size(ctx->md);
  95         ctx->buf = malloc(ctx->key_length);
  96     }
  97 #if 0
  98     ctx->engine = engine;
  99 #endif
 100
 101     if (keylen > EVP_MD_block_size(ctx->md)) {
 102         EVP_Digest(key, keylen, ctx->buf, NULL, ctx->md, engine);
 103         key = ctx->buf;
 104         keylen = EVP_MD_size(ctx->md);
 105     }
 106
 107     if (ctx->opad) {
 108         memset(ctx->opad, 0, ctx->key_length);
 109         free(ctx->opad);
 110     }
 111     if (ctx->ipad) {
 112         memset(ctx->ipad, 0, ctx->key_length);
 113         free(ctx->ipad);
 114     }
 115
 116     ctx->opad = malloc(EVP_MD_block_size(ctx->md));
 117     ctx->ipad = malloc(EVP_MD_block_size(ctx->md));
 118     memset(ctx->ipad, 0x36, EVP_MD_block_size(ctx->md));
 119     memset(ctx->opad, 0x5c, EVP_MD_block_size(ctx->md));
 120
 121     for (i = 0, p = ctx->ipad; i < keylen; i++)
 122         p[i] ^= ((const unsigned char *)key)[i];
 123     for (i = 0, p = ctx->opad; i < keylen; i++)
 124         p[i] ^= ((const unsigned char *)key)[i];
 125
 126     if (ctx->ctx == NULL)
 127         ctx->ctx = EVP_MD_CTX_create();
 128
 129     EVP_DigestInit_ex(ctx->ctx, ctx->md, ctx->engine);
 130     EVP_DigestUpdate(ctx->ctx, ctx->ipad, EVP_MD_block_size(ctx->md));
 131 }
 132
 133 void
 134 HMAC_Update(HMAC_CTX *ctx, const void *data, size_t len)
 135 {
 136     EVP_DigestUpdate(ctx->ctx, data, len);
 137 }
 138
 139 void
 140 HMAC_Final(HMAC_CTX *ctx, void *md, unsigned int *len)
 141 {
 142     EVP_DigestFinal_ex(ctx->ctx, ctx->buf, NULL);
 143
 144     EVP_DigestInit_ex(ctx->ctx, ctx->md, ctx->engine);
 145     EVP_DigestUpdate(ctx->ctx, ctx->opad, EVP_MD_block_size(ctx->md));
 146     EVP_DigestUpdate(ctx->ctx, ctx->buf, ctx->key_length);
 147     EVP_DigestFinal_ex(ctx->ctx, md, len);
 148 }
 149
 150 void *
 151 HMAC(const EVP_MD *md,
 152      const void *key, size_t key_size,
 153      const void *data, size_t data_size,
 154      void *hash, unsigned int *hash_len)
 155 {
 156     HMAC_CTX ctx;
 157
 158     HMAC_CTX_init(&ctx);
 159     HMAC_Init_ex(&ctx, key, key_size, md, NULL);
 160     HMAC_Update(&ctx, data, data_size);
 161     HMAC_Final(&ctx, hash, hash_len);
 162     HMAC_CTX_cleanup(&ctx);
 163     return hash;
 164 }