crypto/blake2/blake2s_mac.c

   1 /*
   2  * Copyright 2018 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (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 #ifndef OPENSSL_NO_BLAKE2
  11
  12 # include <openssl/evp.h>
  13 # include "internal/blake2.h"
  14 # include "internal/cryptlib.h"
  15 # include "internal/evp_int.h"
  16
  17 /* typedef EVP_MAC_IMPL */
  18 struct evp_mac_impl_st {
  19     BLAKE2S_CTX ctx;
  20     BLAKE2S_PARAM params;
  21     unsigned char key[BLAKE2S_KEYBYTES];
  22 };
  23
  24 static EVP_MAC_IMPL *blake2s_mac_new(void)
  25 {
  26     EVP_MAC_IMPL *macctx = OPENSSL_zalloc(sizeof(*macctx));
  27     if (macctx != NULL) {
  28         blake2s_param_init(&macctx->params);
  29         /* ctx initialization is deferred to BLAKE2s_Init() */
  30     }
  31     return macctx;
  32 }
  33
  34 static void blake2s_mac_free(EVP_MAC_IMPL *macctx)
  35 {
  36     if (macctx != NULL) {
  37         OPENSSL_cleanse(macctx->key, sizeof(macctx->key));
  38         OPENSSL_free(macctx);
  39     }
  40 }
  41
  42 static EVP_MAC_IMPL *blake2s_mac_dup(const EVP_MAC_IMPL *src)
  43 {
  44     EVP_MAC_IMPL *dst;
  45
  46     dst = OPENSSL_malloc(sizeof(*dst));
  47     if (dst == NULL)
  48         return NULL;
  49
  50     *dst = *src;
  51     return dst;
  52 }
  53
  54 static int blake2s_mac_init(EVP_MAC_IMPL *macctx)
  55 {
  56     /* Check key has been set */
  57     if (macctx->params.key_length == 0) {
  58         EVPerr(EVP_F_BLAKE2S_MAC_INIT, EVP_R_NO_KEY_SET);
  59         return 0;
  60     }
  61
  62     return blake2s_init_key(&macctx->ctx, &macctx->params, macctx->key);
  63 }
  64
  65 static int blake2s_mac_update(EVP_MAC_IMPL *macctx, const unsigned char *data,
  66                               size_t datalen)
  67 {
  68     return blake2s_update(&macctx->ctx, data, datalen);
  69 }
  70
  71 static int blake2s_mac_final(EVP_MAC_IMPL *macctx, unsigned char *out)
  72 {
  73     return blake2s_final(out, &macctx->ctx);
  74 }
  75
  76 /*
  77  * ALL Ctrl functions should be set before init().
  78  */
  79 static int blake2s_mac_ctrl(EVP_MAC_IMPL *macctx, int cmd, va_list args)
  80 {
  81     const unsigned char *p;
  82     size_t len;
  83     size_t size;
  84
  85     switch (cmd) {
  86         case EVP_MAC_CTRL_SET_SIZE:
  87             size = va_arg(args, size_t);
  88             if (size < 1 || size > BLAKE2S_OUTBYTES) {
  89                 EVPerr(EVP_F_BLAKE2S_MAC_CTRL, EVP_R_NOT_XOF_OR_INVALID_LENGTH);
  90                 return 0;
  91             }
  92             blake2s_param_set_digest_length(&macctx->params, (uint8_t)size);
  93             return 1;
  94
  95         case EVP_MAC_CTRL_SET_KEY:
  96             p = va_arg(args, const unsigned char *);
  97             len = va_arg(args, size_t);
  98             if (len < 1 || len > BLAKE2S_KEYBYTES) {
  99                 EVPerr(EVP_F_BLAKE2S_MAC_CTRL, EVP_R_INVALID_KEY_LENGTH);
 100                 return 0;
 101             }
 102             blake2s_param_set_key_length(&macctx->params, (uint8_t)len);
 103             memcpy(macctx->key, p, len);
 104             memset(macctx->key + len, 0, BLAKE2S_KEYBYTES - len);
 105             return 1;
 106
 107         case EVP_MAC_CTRL_SET_CUSTOM:
 108             p = va_arg(args, const unsigned char *);
 109             len = va_arg(args, size_t);
 110             if (len > BLAKE2S_PERSONALBYTES) {
 111                 EVPerr(EVP_F_BLAKE2S_MAC_CTRL, EVP_R_INVALID_CUSTOM_LENGTH);
 112                 return 0;
 113             }
 114             blake2s_param_set_personal(&macctx->params, p, len);
 115             return 1;
 116
 117         case EVP_MAC_CTRL_SET_SALT:
 118             p = va_arg(args, const unsigned char *);
 119             len = va_arg(args, size_t);
 120             if (len > BLAKE2S_SALTBYTES) {
 121                 EVPerr(EVP_F_BLAKE2S_MAC_CTRL, EVP_R_INVALID_SALT_LENGTH);
 122                 return 0;
 123             }
 124             blake2s_param_set_salt(&macctx->params, p, len);
 125             return 1;
 126
 127         default:
 128             return -2;
 129     }
 130 }
 131
 132 static int blake2s_mac_ctrl_int(EVP_MAC_IMPL *macctx, int cmd, ...)
 133 {
 134     int rv;
 135     va_list args;
 136
 137     va_start(args, cmd);
 138     rv = blake2s_mac_ctrl(macctx, cmd, args);
 139     va_end(args);
 140
 141     return rv;
 142 }
 143
 144 static int blake2s_mac_ctrl_str_cb(void *macctx, int cmd, void *buf, size_t buflen)
 145 {
 146     return blake2s_mac_ctrl_int(macctx, cmd, buf, buflen);
 147 }
 148
 149 static int blake2s_mac_ctrl_str(EVP_MAC_IMPL *macctx, const char *type,
 150                                 const char *value)
 151 {
 152     if (value == NULL)
 153         return 0;
 154
 155     if (strcmp(type, "outlen") == 0)
 156         return blake2s_mac_ctrl_int(macctx, EVP_MAC_CTRL_SET_SIZE, (size_t)atoi(value));
 157     if (strcmp(type, "key") == 0)
 158         return EVP_str2ctrl(blake2s_mac_ctrl_str_cb, macctx, EVP_MAC_CTRL_SET_KEY,
 159                             value);
 160     if (strcmp(type, "hexkey") == 0)
 161         return EVP_hex2ctrl(blake2s_mac_ctrl_str_cb, macctx, EVP_MAC_CTRL_SET_KEY,
 162                             value);
 163     if (strcmp(type, "custom") == 0)
 164         return EVP_str2ctrl(blake2s_mac_ctrl_str_cb, macctx, EVP_MAC_CTRL_SET_CUSTOM,
 165                             value);
 166     if (strcmp(type, "hexcustom") == 0)
 167         return EVP_hex2ctrl(blake2s_mac_ctrl_str_cb, macctx, EVP_MAC_CTRL_SET_CUSTOM,
 168                             value);
 169     if (strcmp(type, "salt") == 0)
 170         return EVP_str2ctrl(blake2s_mac_ctrl_str_cb, macctx, EVP_MAC_CTRL_SET_SALT,
 171                             value);
 172     if (strcmp(type, "hexsalt") == 0)
 173         return EVP_hex2ctrl(blake2s_mac_ctrl_str_cb, macctx, EVP_MAC_CTRL_SET_SALT,
 174                             value);
 175     return -2;
 176 }
 177
 178 static size_t blake2s_mac_size(EVP_MAC_IMPL *macctx)
 179 {
 180     return macctx->params.digest_length;
 181 }
 182
 183 const EVP_MAC blake2s_mac_meth = {
 184     EVP_MAC_BLAKE2S,
 185     blake2s_mac_new,
 186     blake2s_mac_dup,
 187     blake2s_mac_free,
 188     blake2s_mac_size,
 189     blake2s_mac_init,
 190     blake2s_mac_update,
 191     blake2s_mac_final,
 192     blake2s_mac_ctrl,
 193     blake2s_mac_ctrl_str
 194 };
 195
 196 #endif