crypto/hmac/hmac.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include "internal/cryptlib.h"
  14 #include <openssl/hmac.h>
  15 #include <openssl/opensslconf.h>
  16 #include "hmac_lcl.h"
  17
  18 int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
  19                  const EVP_MD *md, ENGINE *impl)
  20 {
  21     int i, j, reset = 0;
  22     unsigned char pad[HMAC_MAX_MD_CBLOCK];
  23
  24     /* If we are changing MD then we must have a key */
  25     if (md != NULL && md != ctx->md && (key == NULL || len < 0))
  26         return 0;
  27
  28     if (md != NULL) {
  29         reset = 1;
  30         ctx->md = md;
  31     } else if (ctx->md) {
  32         md = ctx->md;
  33     } else {
  34         return 0;
  35     }
  36
  37     if (key != NULL) {
  38         reset = 1;
  39         j = EVP_MD_block_size(md);
  40         if (!ossl_assert(j <= (int)sizeof(ctx->key)))
  41             goto err;
  42         if (j < len) {
  43             if (!EVP_DigestInit_ex(ctx->md_ctx, md, impl))
  44                 goto err;
  45             if (!EVP_DigestUpdate(ctx->md_ctx, key, len))
  46                 goto err;
  47             if (!EVP_DigestFinal_ex(ctx->md_ctx, ctx->key,
  48                                     &ctx->key_length))
  49                 goto err;
  50         } else {
  51             if (len < 0 || len > (int)sizeof(ctx->key))
  52                 return 0;
  53             memcpy(ctx->key, key, len);
  54             ctx->key_length = len;
  55         }
  56         if (ctx->key_length != HMAC_MAX_MD_CBLOCK)
  57             memset(&ctx->key[ctx->key_length], 0,
  58                    HMAC_MAX_MD_CBLOCK - ctx->key_length);
  59     }
  60
  61     if (reset) {
  62         for (i = 0; i < HMAC_MAX_MD_CBLOCK; i++)
  63             pad[i] = 0x36 ^ ctx->key[i];
  64         if (!EVP_DigestInit_ex(ctx->i_ctx, md, impl))
  65             goto err;
  66         if (!EVP_DigestUpdate(ctx->i_ctx, pad, EVP_MD_block_size(md)))
  67             goto err;
  68
  69         for (i = 0; i < HMAC_MAX_MD_CBLOCK; i++)
  70             pad[i] = 0x5c ^ ctx->key[i];
  71         if (!EVP_DigestInit_ex(ctx->o_ctx, md, impl))
  72             goto err;
  73         if (!EVP_DigestUpdate(ctx->o_ctx, pad, EVP_MD_block_size(md)))
  74             goto err;
  75     }
  76     if (!EVP_MD_CTX_copy_ex(ctx->md_ctx, ctx->i_ctx))
  77         goto err;
  78     return 1;
  79  err:
  80     return 0;
  81 }
  82
  83 #if OPENSSL_API_COMPAT < 0x10100000L
  84 int HMAC_Init(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md)
  85 {
  86     if (key && md)
  87         HMAC_CTX_reset(ctx);
  88     return HMAC_Init_ex(ctx, key, len, md, NULL);
  89 }
  90 #endif
  91
  92 int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, size_t len)
  93 {
  94     if (!ctx->md)
  95         return 0;
  96     return EVP_DigestUpdate(ctx->md_ctx, data, len);
  97 }
  98
  99 int HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len)
 100 {
 101     unsigned int i;
 102     unsigned char buf[EVP_MAX_MD_SIZE];
 103
 104     if (!ctx->md)
 105         goto err;
 106
 107     if (!EVP_DigestFinal_ex(ctx->md_ctx, buf, &i))
 108         goto err;
 109     if (!EVP_MD_CTX_copy_ex(ctx->md_ctx, ctx->o_ctx))
 110         goto err;
 111     if (!EVP_DigestUpdate(ctx->md_ctx, buf, i))
 112         goto err;
 113     if (!EVP_DigestFinal_ex(ctx->md_ctx, md, len))
 114         goto err;
 115     return 1;
 116  err:
 117     return 0;
 118 }
 119
 120 size_t HMAC_size(const HMAC_CTX *ctx)
 121 {
 122     int size = EVP_MD_size((ctx)->md);
 123
 124     return (size < 0) ? 0 : size;
 125 }
 126
 127 HMAC_CTX *HMAC_CTX_new(void)
 128 {
 129     HMAC_CTX *ctx = OPENSSL_zalloc(sizeof(HMAC_CTX));
 130
 131     if (ctx != NULL) {
 132         if (!HMAC_CTX_reset(ctx)) {
 133             HMAC_CTX_free(ctx);
 134             return NULL;
 135         }
 136     }
 137     return ctx;
 138 }
 139
 140 static void hmac_ctx_cleanup(HMAC_CTX *ctx)
 141 {
 142     EVP_MD_CTX_reset(ctx->i_ctx);
 143     EVP_MD_CTX_reset(ctx->o_ctx);
 144     EVP_MD_CTX_reset(ctx->md_ctx);
 145     ctx->md = NULL;
 146     ctx->key_length = 0;
 147     OPENSSL_cleanse(ctx->key, sizeof(ctx->key));
 148 }
 149
 150 void HMAC_CTX_free(HMAC_CTX *ctx)
 151 {
 152     if (ctx != NULL) {
 153         hmac_ctx_cleanup(ctx);
 154         EVP_MD_CTX_free(ctx->i_ctx);
 155         EVP_MD_CTX_free(ctx->o_ctx);
 156         EVP_MD_CTX_free(ctx->md_ctx);
 157         OPENSSL_free(ctx);
 158     }
 159 }
 160
 161 static int hmac_ctx_alloc_mds(HMAC_CTX *ctx)
 162 {
 163     if (ctx->i_ctx == NULL)
 164         ctx->i_ctx = EVP_MD_CTX_new();
 165     if (ctx->i_ctx == NULL)
 166         return 0;
 167     if (ctx->o_ctx == NULL)
 168         ctx->o_ctx = EVP_MD_CTX_new();
 169     if (ctx->o_ctx == NULL)
 170         return 0;
 171     if (ctx->md_ctx == NULL)
 172         ctx->md_ctx = EVP_MD_CTX_new();
 173     if (ctx->md_ctx == NULL)
 174         return 0;
 175     return 1;
 176 }
 177
 178 int HMAC_CTX_reset(HMAC_CTX *ctx)
 179 {
 180     hmac_ctx_cleanup(ctx);
 181     if (!hmac_ctx_alloc_mds(ctx)) {
 182         hmac_ctx_cleanup(ctx);
 183         return 0;
 184     }
 185     return 1;
 186 }
 187
 188 int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx)
 189 {
 190     if (!hmac_ctx_alloc_mds(dctx))
 191         goto err;
 192     if (!EVP_MD_CTX_copy_ex(dctx->i_ctx, sctx->i_ctx))
 193         goto err;
 194     if (!EVP_MD_CTX_copy_ex(dctx->o_ctx, sctx->o_ctx))
 195         goto err;
 196     if (!EVP_MD_CTX_copy_ex(dctx->md_ctx, sctx->md_ctx))
 197         goto err;
 198     memcpy(dctx->key, sctx->key, HMAC_MAX_MD_CBLOCK);
 199     dctx->key_length = sctx->key_length;
 200     dctx->md = sctx->md;
 201     return 1;
 202  err:
 203     hmac_ctx_cleanup(dctx);
 204     return 0;
 205 }
 206
 207 unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,
 208                     const unsigned char *d, size_t n, unsigned char *md,
 209                     unsigned int *md_len)
 210 {
 211     HMAC_CTX *c = NULL;
 212     static unsigned char m[EVP_MAX_MD_SIZE];
 213     static const unsigned char dummy_key[1] = {'\0'};
 214
 215     if (md == NULL)
 216         md = m;
 217     if ((c = HMAC_CTX_new()) == NULL)
 218         goto err;
 219
 220     /* For HMAC_Init_ex, NULL key signals reuse. */
 221     if (key == NULL && key_len == 0) {
 222         key = dummy_key;
 223     }
 224
 225     if (!HMAC_Init_ex(c, key, key_len, evp_md, NULL))
 226         goto err;
 227     if (!HMAC_Update(c, d, n))
 228         goto err;
 229     if (!HMAC_Final(c, md, md_len))
 230         goto err;
 231     HMAC_CTX_free(c);
 232     return md;
 233  err:
 234     HMAC_CTX_free(c);
 235     return NULL;
 236 }
 237
 238 void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags)
 239 {
 240     EVP_MD_CTX_set_flags(ctx->i_ctx, flags);
 241     EVP_MD_CTX_set_flags(ctx->o_ctx, flags);
 242     EVP_MD_CTX_set_flags(ctx->md_ctx, flags);
 243 }
 244
 245 const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx)
 246 {
 247     return ctx->md;
 248 }