Home | History | Annotate | Line # | Download | only in evp 
      1 /*
      2  * Copyright 2018-2021 The OpenSSL Project Authors. All Rights Reserved.
      3  * Copyright (c) 2018-2019, Oracle and/or its affiliates.  All rights reserved.
      4  *
      5  * Licensed under the Apache License 2.0 (the "License").  You may not use
      6  * this file except in compliance with the License.  You can obtain a copy
      7  * in the file LICENSE in the source distribution or at
      8  * https://www.openssl.org/source/license.html
      9  */
     10 
     11 #include <stdio.h>
     12 #include <stdlib.h>
     13 #include "internal/cryptlib.h"
     14 #include <openssl/evp.h>
     15 #include <openssl/kdf.h>
     16 #include <openssl/core.h>
     17 #include <openssl/core_names.h>
     18 #include "crypto/evp.h"
     19 #include "internal/numbers.h"
     20 #include "internal/provider.h"
     21 #include "evp_local.h"
     22 
     23 EVP_KDF_CTX *EVP_KDF_CTX_new(EVP_KDF *kdf)
     24 {
     25     EVP_KDF_CTX *ctx = NULL;
     26 
     27     if (kdf == NULL)
     28         return NULL;
     29 
     30     ctx = OPENSSL_zalloc(sizeof(EVP_KDF_CTX));
     31     if (ctx == NULL
     32         || (ctx->algctx = kdf->newctx(ossl_provider_ctx(kdf->prov))) == NULL
     33         || !EVP_KDF_up_ref(kdf)) {
     34         ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
     35         if (ctx != NULL)
     36             kdf->freectx(ctx->algctx);
     37         OPENSSL_free(ctx);
     38         ctx = NULL;
     39     } else {
     40         ctx->meth = kdf;
     41     }
     42     return ctx;
     43 }
     44 
     45 void EVP_KDF_CTX_free(EVP_KDF_CTX *ctx)
     46 {
     47     if (ctx == NULL)
     48         return;
     49     ctx->meth->freectx(ctx->algctx);
     50     ctx->algctx = NULL;
     51     EVP_KDF_free(ctx->meth);
     52     OPENSSL_free(ctx);
     53 }
     54 
     55 EVP_KDF_CTX *EVP_KDF_CTX_dup(const EVP_KDF_CTX *src)
     56 {
     57     EVP_KDF_CTX *dst;
     58 
     59     if (src == NULL || src->algctx == NULL || src->meth->dupctx == NULL)
     60         return NULL;
     61 
     62     dst = OPENSSL_malloc(sizeof(*dst));
     63     if (dst == NULL)
     64         return NULL;
     65 
     66     memcpy(dst, src, sizeof(*dst));
     67     if (!EVP_KDF_up_ref(dst->meth)) {
     68         ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
     69         OPENSSL_free(dst);
     70         return NULL;
     71     }
     72 
     73     dst->algctx = src->meth->dupctx(src->algctx);
     74     if (dst->algctx == NULL) {
     75         EVP_KDF_CTX_free(dst);
     76         return NULL;
     77     }
     78     return dst;
     79 }
     80 
     81 int evp_kdf_get_number(const EVP_KDF *kdf)
     82 {
     83     return kdf->name_id;
     84 }
     85 
     86 const char *EVP_KDF_get0_name(const EVP_KDF *kdf)
     87 {
     88     return kdf->type_name;
     89 }
     90 
     91 const char *EVP_KDF_get0_description(const EVP_KDF *kdf)
     92 {
     93     return kdf->description;
     94 }
     95 
     96 int EVP_KDF_is_a(const EVP_KDF *kdf, const char *name)
     97 {
     98     return kdf != NULL && evp_is_a(kdf->prov, kdf->name_id, NULL, name);
     99 }
    100 
    101 const OSSL_PROVIDER *EVP_KDF_get0_provider(const EVP_KDF *kdf)
    102 {
    103     return kdf->prov;
    104 }
    105 
    106 const EVP_KDF *EVP_KDF_CTX_kdf(EVP_KDF_CTX *ctx)
    107 {
    108     return ctx->meth;
    109 }
    110 
    111 void EVP_KDF_CTX_reset(EVP_KDF_CTX *ctx)
    112 {
    113     if (ctx == NULL)
    114         return;
    115 
    116     if (ctx->meth->reset != NULL)
    117         ctx->meth->reset(ctx->algctx);
    118 }
    119 
    120 size_t EVP_KDF_CTX_get_kdf_size(EVP_KDF_CTX *ctx)
    121 {
    122     OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
    123     size_t s = 0;
    124 
    125     if (ctx == NULL)
    126         return 0;
    127 
    128     *params = OSSL_PARAM_construct_size_t(OSSL_KDF_PARAM_SIZE, &s);
    129     if (ctx->meth->get_ctx_params != NULL
    130         && ctx->meth->get_ctx_params(ctx->algctx, params))
    131         return s;
    132     if (ctx->meth->get_params != NULL
    133         && ctx->meth->get_params(params))
    134         return s;
    135     return 0;
    136 }
    137 
    138 int EVP_KDF_derive(EVP_KDF_CTX *ctx, unsigned char *key, size_t keylen,
    139     const OSSL_PARAM params[])
    140 {
    141     if (ctx == NULL)
    142         return 0;
    143 
    144     return ctx->meth->derive(ctx->algctx, key, keylen, params);
    145 }
    146 
    147 /*
    148  * The {get,set}_params functions return 1 if there is no corresponding
    149  * function in the implementation.  This is the same as if there was one,
    150  * but it didn't recognise any of the given params, i.e. nothing in the
    151  * bag of parameters was useful.
    152  */
    153 int EVP_KDF_get_params(EVP_KDF *kdf, OSSL_PARAM params[])
    154 {
    155     if (kdf->get_params != NULL)
    156         return kdf->get_params(params);
    157     return 1;
    158 }
    159 
    160 int EVP_KDF_CTX_get_params(EVP_KDF_CTX *ctx, OSSL_PARAM params[])
    161 {
    162     if (ctx->meth->get_ctx_params != NULL)
    163         return ctx->meth->get_ctx_params(ctx->algctx, params);
    164     return 1;
    165 }
    166 
    167 int EVP_KDF_CTX_set_params(EVP_KDF_CTX *ctx, const OSSL_PARAM params[])
    168 {
    169     if (ctx->meth->set_ctx_params != NULL)
    170         return ctx->meth->set_ctx_params(ctx->algctx, params);
    171     return 1;
    172 }
    173 
    174 int EVP_KDF_names_do_all(const EVP_KDF *kdf,
    175     void (*fn)(const char *name, void *data),
    176     void *data)
    177 {
    178     if (kdf->prov != NULL)
    179         return evp_names_do_all(kdf->prov, kdf->name_id, fn, data);
    180 
    181     return 1;
    182 }
    183