Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
freebsd
GitHub Repository: freebsd/freebsd-src
 Path: blob/main/crypto/openssl/providers/implementations/kdfs/hmacdrbg_kdf.c
48383 views
1
/*

2
 * Copyright 2022-2024 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 <stdlib.h>

11
#include <string.h>

12
#include <openssl/crypto.h>

13
#include <openssl/err.h>

14
#include <openssl/kdf.h>

15
#include <openssl/proverr.h>

16
#include <openssl/core_names.h>

17
#include "prov/providercommon.h"

18
#include "prov/implementations.h"

19
#include "prov/hmac_drbg.h"

20
#include "prov/provider_ctx.h"

21


22
static OSSL_FUNC_kdf_newctx_fn hmac_drbg_kdf_new;

23
static OSSL_FUNC_kdf_dupctx_fn hmac_drbg_kdf_dup;

24
static OSSL_FUNC_kdf_freectx_fn hmac_drbg_kdf_free;

25
static OSSL_FUNC_kdf_reset_fn hmac_drbg_kdf_reset;

26
static OSSL_FUNC_kdf_derive_fn hmac_drbg_kdf_derive;

27
static OSSL_FUNC_kdf_settable_ctx_params_fn hmac_drbg_kdf_settable_ctx_params;

28
static OSSL_FUNC_kdf_set_ctx_params_fn hmac_drbg_kdf_set_ctx_params;

29
static OSSL_FUNC_kdf_gettable_ctx_params_fn hmac_drbg_kdf_gettable_ctx_params;

30
static OSSL_FUNC_kdf_get_ctx_params_fn hmac_drbg_kdf_get_ctx_params;

31


32
typedef struct {

33
    PROV_DRBG_HMAC base;

34
    void *provctx;

35
    unsigned char *entropy, *nonce;

36
    size_t entropylen, noncelen;

37
    int init;

38
} KDF_HMAC_DRBG;

39


40
static void *hmac_drbg_kdf_new(void *provctx)

41
{

42
    KDF_HMAC_DRBG *ctx;

43


44
    if (!ossl_prov_is_running())

45
        return NULL;

46


47
    ctx = OPENSSL_zalloc(sizeof(*ctx));

48
    if (ctx == NULL) {

49
        ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);

50
        return NULL;

51
    }

52
    ctx->provctx = provctx;

53
    return ctx;

54
}

55


56
static void hmac_drbg_kdf_reset(void *vctx)

57
{

58
    KDF_HMAC_DRBG *ctx = (KDF_HMAC_DRBG *)vctx;

59
    PROV_DRBG_HMAC *drbg = &ctx->base;

60
    void *provctx = ctx->provctx;

61


62
    EVP_MAC_CTX_free(drbg->ctx);

63
    ossl_prov_digest_reset(&drbg->digest);

64
    OPENSSL_clear_free(ctx->entropy, ctx->entropylen);

65
    OPENSSL_clear_free(ctx->nonce, ctx->noncelen);

66
    OPENSSL_cleanse(ctx, sizeof(*ctx));

67
    ctx->provctx = provctx;

68
}

69


70
static void hmac_drbg_kdf_free(void *vctx)

71
{

72
    KDF_HMAC_DRBG *ctx = (KDF_HMAC_DRBG *)vctx;

73


74
    if (ctx != NULL) {

75
        hmac_drbg_kdf_reset(ctx);

76
        OPENSSL_free(ctx);

77
    }

78
}

79


80
static int ossl_drbg_hmac_dup(PROV_DRBG_HMAC *dst, const PROV_DRBG_HMAC *src) {

81
    if (src->ctx != NULL) {

82
        dst->ctx = EVP_MAC_CTX_dup(src->ctx);

83
        if (dst->ctx == NULL)

84
            return 0;

85
    }

86
    if (!ossl_prov_digest_copy(&dst->digest, &src->digest))

87
        return 0;

88
    memcpy(dst->K, src->K, sizeof(dst->K));

89
    memcpy(dst->V, src->V, sizeof(dst->V));

90
    dst->blocklen = src->blocklen;

91
    return 1;

92
}

93


94
static void *hmac_drbg_kdf_dup(void *vctx)

95
{

96
    const KDF_HMAC_DRBG *src = (const KDF_HMAC_DRBG *)vctx;

97
    KDF_HMAC_DRBG *dst;

98


99
    dst = hmac_drbg_kdf_new(src->provctx);

100
    if (dst != NULL) {

101
        if (!ossl_drbg_hmac_dup(&dst->base, &src->base)

102
                || !ossl_prov_memdup(src->entropy, src->entropylen,

103
                                     &dst->entropy , &dst->entropylen)

104
                || !ossl_prov_memdup(src->nonce, src->noncelen,

105
                                     &dst->nonce, &dst->noncelen))

106
            goto err;

107
        dst->init = src->init;

108
    }

109
    return dst;

110


111
 err:

112
    hmac_drbg_kdf_free(dst);

113
    return NULL;

114
}

115


116
static int hmac_drbg_kdf_derive(void *vctx, unsigned char *out, size_t outlen,

117
                                const OSSL_PARAM params[])

118
{

119
    KDF_HMAC_DRBG *ctx = (KDF_HMAC_DRBG *)vctx;

120
    PROV_DRBG_HMAC *drbg = &ctx->base;

121


122
    if (!ossl_prov_is_running()

123
            || !hmac_drbg_kdf_set_ctx_params(vctx, params))

124
        return 0;

125
    if (!ctx->init) {

126
        if (ctx->entropy == NULL

127
                || ctx->entropylen == 0

128
                || ctx->nonce == NULL

129
                || ctx->noncelen == 0

130
                || !ossl_drbg_hmac_init(drbg, ctx->entropy, ctx->entropylen,

131
                                        ctx->nonce, ctx->noncelen, NULL, 0))

132
            return 0;

133
        ctx->init = 1;

134
    }

135


136
    return ossl_drbg_hmac_generate(drbg, out, outlen, NULL, 0);

137
}

138


139
static int hmac_drbg_kdf_get_ctx_params(void *vctx, OSSL_PARAM params[])

140
{

141
    KDF_HMAC_DRBG *hmac = (KDF_HMAC_DRBG *)vctx;

142
    PROV_DRBG_HMAC *drbg = &hmac->base;

143
    const char *name;

144
    const EVP_MD *md;

145
    OSSL_PARAM *p;

146


147
    p = OSSL_PARAM_locate(params, OSSL_KDF_PARAM_MAC);

148
    if (p != NULL) {

149
        if (drbg->ctx == NULL)

150
            return 0;

151
        name = EVP_MAC_get0_name(EVP_MAC_CTX_get0_mac(drbg->ctx));

152
        if (!OSSL_PARAM_set_utf8_string(p, name))

153
            return 0;

154
    }

155


156
    p = OSSL_PARAM_locate(params, OSSL_KDF_PARAM_DIGEST);

157
    if (p != NULL) {

158
        md = ossl_prov_digest_md(&drbg->digest);

159
        if (md == NULL || !OSSL_PARAM_set_utf8_string(p, EVP_MD_get0_name(md)))

160
            return 0;

161
    }

162
    return 1;

163
}

164


165
static const OSSL_PARAM *hmac_drbg_kdf_gettable_ctx_params(

166
    ossl_unused void *vctx, ossl_unused void *p_ctx)

167
{

168
    static const OSSL_PARAM known_gettable_ctx_params[] = {

169
        OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MAC, NULL, 0),

170
        OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_DIGEST, NULL, 0),

171
        OSSL_PARAM_END

172
    };

173
    return known_gettable_ctx_params;

174
}

175


176
static int hmac_drbg_kdf_set_ctx_params(void *vctx,

177
                                        const OSSL_PARAM params[])

178
{

179
    KDF_HMAC_DRBG *hmac = (KDF_HMAC_DRBG *)vctx;

180
    PROV_DRBG_HMAC *drbg = &hmac->base;

181
    OSSL_LIB_CTX *libctx = PROV_LIBCTX_OF(hmac->provctx);

182
    const EVP_MD *md;

183
    const OSSL_PARAM *p;

184
    void *ptr = NULL;

185
    size_t size = 0;

186
    int md_size;

187


188
    if (ossl_param_is_empty(params))

189
        return 1;

190


191
    p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_HMACDRBG_ENTROPY);

192
    if (p != NULL) {

193
        if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))

194
            return 0;

195
        OPENSSL_free(hmac->entropy);

196
        hmac->entropy = ptr;

197
        hmac->entropylen = size;

198
        hmac->init = 0;

199
        ptr = NULL;

200
    }

201


202
    p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_HMACDRBG_NONCE);

203
    if (p != NULL) {

204
        if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))

205
            return 0;

206
        OPENSSL_free(hmac->nonce);

207
        hmac->nonce = ptr;

208
        hmac->noncelen = size;

209
        hmac->init = 0;

210
    }

211


212
    p = OSSL_PARAM_locate_const(params, OSSL_ALG_PARAM_DIGEST);

213
    if (p != NULL) {

214
        if (!ossl_prov_digest_load_from_params(&drbg->digest, params, libctx))

215
            return 0;

216


217
        /* Confirm digest is allowed. Allow all digests that are not XOF */

218
        md = ossl_prov_digest_md(&drbg->digest);

219
        if (md != NULL) {

220
            if (EVP_MD_xof(md)) {

221
                ERR_raise(ERR_LIB_PROV, PROV_R_XOF_DIGESTS_NOT_ALLOWED);

222
                return 0;

223
            }

224
            md_size = EVP_MD_get_size(md);

225
            if (md_size <= 0)

226
                return 0;

227
            drbg->blocklen = (size_t)md_size;

228
        }

229
        return ossl_prov_macctx_load_from_params(&drbg->ctx, params,

230
                                                 "HMAC", NULL, NULL, libctx);

231
    }

232
    return 1;

233
}

234


235
static const OSSL_PARAM *hmac_drbg_kdf_settable_ctx_params(

236
    ossl_unused void *vctx, ossl_unused void *p_ctx)

237
{

238
    static const OSSL_PARAM known_settable_ctx_params[] = {

239
        OSSL_PARAM_octet_string(OSSL_KDF_PARAM_HMACDRBG_ENTROPY, NULL, 0),

240
        OSSL_PARAM_octet_string(OSSL_KDF_PARAM_HMACDRBG_NONCE, NULL, 0),

241
        OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_DIGEST, NULL, 0),

242
        OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_PROPERTIES, NULL, 0),

243
        OSSL_PARAM_END

244
    };

245
    return known_settable_ctx_params;

246
}

247


248
const OSSL_DISPATCH ossl_kdf_hmac_drbg_functions[] = {

249
    { OSSL_FUNC_KDF_NEWCTX, (void(*)(void))hmac_drbg_kdf_new },

250
    { OSSL_FUNC_KDF_FREECTX, (void(*)(void))hmac_drbg_kdf_free },

251
    { OSSL_FUNC_KDF_DUPCTX, (void(*)(void))hmac_drbg_kdf_dup },

252
    { OSSL_FUNC_KDF_RESET, (void(*)(void))hmac_drbg_kdf_reset },

253
    { OSSL_FUNC_KDF_DERIVE, (void(*)(void))hmac_drbg_kdf_derive },

254
    { OSSL_FUNC_KDF_SETTABLE_CTX_PARAMS,

255
      (void(*)(void))hmac_drbg_kdf_settable_ctx_params },

256
    { OSSL_FUNC_KDF_SET_CTX_PARAMS,

257
      (void(*)(void))hmac_drbg_kdf_set_ctx_params },

258
    { OSSL_FUNC_KDF_GETTABLE_CTX_PARAMS,

259
      (void(*)(void))hmac_drbg_kdf_gettable_ctx_params },

260
    { OSSL_FUNC_KDF_GET_CTX_PARAMS,

261
      (void(*)(void))hmac_drbg_kdf_get_ctx_params },

262
    OSSL_DISPATCH_END

263
};

264


265