crypto/evp/mac_lib.c

   1 /*
   2  * Copyright 2018-2020 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 #include <string.h>
  11 #include <stdarg.h>
  12 #include <openssl/evp.h>
  13 #include <openssl/err.h>
  14 #include <openssl/core.h>
  15 #include <openssl/core_names.h>
  16 #include <openssl/types.h>
  17 #include "internal/nelem.h"
  18 #include "crypto/evp.h"
  19 #include "internal/provider.h"
  20 #include "evp_local.h"
  21
  22 EVP_MAC_CTX *EVP_MAC_CTX_new(EVP_MAC *mac)
  23 {
  24     EVP_MAC_CTX *ctx = OPENSSL_zalloc(sizeof(EVP_MAC_CTX));
  25
  26     if (ctx == NULL
  27         || (ctx->data = mac->newctx(ossl_provider_ctx(mac->prov))) == NULL
  28         || !EVP_MAC_up_ref(mac)) {
  29         EVPerr(EVP_F_EVP_MAC_CTX_NEW, ERR_R_MALLOC_FAILURE);
  30         if (ctx != NULL)
  31             mac->freectx(ctx->data);
  32         OPENSSL_free(ctx);
  33         ctx = NULL;
  34     } else {
  35         ctx->meth = mac;
  36     }
  37     return ctx;
  38 }
  39
  40 void EVP_MAC_CTX_free(EVP_MAC_CTX *ctx)
  41 {
  42     if (ctx != NULL) {
  43         ctx->meth->freectx(ctx->data);
  44         ctx->data = NULL;
  45         /* refcnt-- */
  46         EVP_MAC_free(ctx->meth);
  47     }
  48     OPENSSL_free(ctx);
  49 }
  50
  51 EVP_MAC_CTX *EVP_MAC_CTX_dup(const EVP_MAC_CTX *src)
  52 {
  53     EVP_MAC_CTX *dst;
  54
  55     if (src->data == NULL)
  56         return NULL;
  57
  58     dst = OPENSSL_malloc(sizeof(*dst));
  59     if (dst == NULL) {
  60         EVPerr(EVP_F_EVP_MAC_CTX_DUP, ERR_R_MALLOC_FAILURE);
  61         return NULL;
  62     }
  63
  64     *dst = *src;
  65     if (!EVP_MAC_up_ref(dst->meth)) {
  66         EVPerr(EVP_F_EVP_MAC_CTX_DUP, ERR_R_MALLOC_FAILURE);
  67         OPENSSL_free(dst);
  68         return NULL;
  69     }
  70
  71     dst->data = src->meth->dupctx(src->data);
  72     if (dst->data == NULL) {
  73         EVP_MAC_CTX_free(dst);
  74         return NULL;
  75     }
  76
  77     return dst;
  78 }
  79
  80 EVP_MAC *EVP_MAC_CTX_mac(EVP_MAC_CTX *ctx)
  81 {
  82     return ctx->meth;
  83 }
  84
  85 size_t EVP_MAC_CTX_get_mac_size(EVP_MAC_CTX *ctx)
  86 {
  87     size_t sz = 0;
  88
  89     if (ctx->data != NULL) {
  90         OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
  91
  92         params[0] = OSSL_PARAM_construct_size_t(OSSL_MAC_PARAM_SIZE, &sz);
  93         if (ctx->meth->get_ctx_params != NULL) {
  94             if (ctx->meth->get_ctx_params(ctx->data, params))
  95                 return sz;
  96         } else if (ctx->meth->get_params != NULL) {
  97             if (ctx->meth->get_params(params))
  98                 return sz;
  99         }
 100     }
 101     /*
 102      * If the MAC hasn't been initialized yet, or there is no size to get,
 103      * we return zero
 104      */
 105     return 0;
 106 }
 107
 108 int EVP_MAC_init(EVP_MAC_CTX *ctx)
 109 {
 110     return ctx->meth->init(ctx->data);
 111 }
 112
 113 int EVP_MAC_update(EVP_MAC_CTX *ctx, const unsigned char *data, size_t datalen)
 114 {
 115     return ctx->meth->update(ctx->data, data, datalen);
 116 }
 117
 118 int EVP_MAC_final(EVP_MAC_CTX *ctx,
 119                   unsigned char *out, size_t *outl, size_t outsize)
 120 {
 121     size_t l;
 122     int res = 1;
 123
 124     if (out != NULL)
 125         res = ctx->meth->final(ctx->data, out, &l, outsize);
 126     else
 127         l = EVP_MAC_CTX_get_mac_size(ctx);
 128     if (outl != NULL)
 129         *outl = l;
 130     return res;
 131 }
 132
 133 /*
 134  * The {get,set}_params functions return 1 if there is no corresponding
 135  * function in the implementation.  This is the same as if there was one,
 136  * but it didn't recognise any of the given params, i.e. nothing in the
 137  * bag of parameters was useful.
 138  */
 139 int EVP_MAC_get_params(EVP_MAC *mac, OSSL_PARAM params[])
 140 {
 141     if (mac->get_params != NULL)
 142         return mac->get_params(params);
 143     return 1;
 144 }
 145
 146 int EVP_MAC_CTX_get_params(EVP_MAC_CTX *ctx, OSSL_PARAM params[])
 147 {
 148     if (ctx->meth->get_ctx_params != NULL)
 149         return ctx->meth->get_ctx_params(ctx->data, params);
 150     return 1;
 151 }
 152
 153 int EVP_MAC_CTX_set_params(EVP_MAC_CTX *ctx, const OSSL_PARAM params[])
 154 {
 155     if (ctx->meth->set_ctx_params != NULL)
 156         return ctx->meth->set_ctx_params(ctx->data, params);
 157     return 1;
 158 }
 159
 160 int EVP_MAC_number(const EVP_MAC *mac)
 161 {
 162     return mac->name_id;
 163 }
 164
 165 const char *EVP_MAC_name(const EVP_MAC *mac)
 166 {
 167     if (mac->prov != NULL)
 168         return evp_first_name(mac->prov, mac->name_id);
 169     return NULL;
 170 }
 171
 172 int EVP_MAC_is_a(const EVP_MAC *mac, const char *name)
 173 {
 174     return evp_is_a(mac->prov, mac->name_id, NULL, name);
 175 }
 176
 177 void EVP_MAC_names_do_all(const EVP_MAC *mac,
 178                           void (*fn)(const char *name, void *data),
 179                           void *data)
 180 {
 181     if (mac->prov != NULL)
 182         evp_names_do_all(mac->prov, mac->name_id, fn, data);
 183 }