2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
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
11 #include "internal/cryptlib.h"
12 #include <openssl/objects.h>
13 #include <openssl/evp.h>
14 #include <openssl/engine.h>
15 #include "internal/evp_int.h"
18 /* This call frees resources associated with the context */
19 int EVP_MD_CTX_reset(EVP_MD_CTX *ctx)
25 * Don't assume ctx->md_data was cleaned in EVP_Digest_Final, because
26 * sometimes only copies of the context are ever finalised.
28 if (ctx->digest && ctx->digest->cleanup
29 && !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_CLEANED))
30 ctx->digest->cleanup(ctx);
31 if (ctx->digest && ctx->digest->ctx_size && ctx->md_data
32 && !EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_REUSE)) {
33 OPENSSL_clear_free(ctx->md_data, ctx->digest->ctx_size);
35 EVP_PKEY_CTX_free(ctx->pctx);
36 #ifndef OPENSSL_NO_ENGINE
37 ENGINE_finish(ctx->engine);
39 OPENSSL_cleanse(ctx, sizeof(*ctx));
44 EVP_MD_CTX *EVP_MD_CTX_new(void)
46 return OPENSSL_zalloc(sizeof(EVP_MD_CTX));
49 void EVP_MD_CTX_free(EVP_MD_CTX *ctx)
51 EVP_MD_CTX_reset(ctx);
55 int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type)
57 EVP_MD_CTX_reset(ctx);
58 return EVP_DigestInit_ex(ctx, type, NULL);
61 int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)
63 EVP_MD_CTX_clear_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);
64 #ifndef OPENSSL_NO_ENGINE
66 * Whether it's nice or not, "Inits" can be used on "Final"'d contexts so
67 * this context may already have an ENGINE! Try to avoid releasing the
68 * previous handle, re-querying for an ENGINE, and having a
69 * reinitialisation, when it may all be unnecessary.
71 if (ctx->engine && ctx->digest &&
72 (type == NULL || (type->type == ctx->digest->type)))
76 * Ensure an ENGINE left lying around from last time is cleared (the
77 * previous check attempted to avoid this if the same ENGINE and
78 * EVP_MD could be used).
80 ENGINE_finish(ctx->engine);
82 if (!ENGINE_init(impl)) {
83 EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_INITIALIZATION_ERROR);
87 /* Ask if an ENGINE is reserved for this job */
88 impl = ENGINE_get_digest_engine(type->type);
91 /* There's an ENGINE for this job ... (apparently) */
92 const EVP_MD *d = ENGINE_get_digest(impl, type->type);
95 EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_INITIALIZATION_ERROR);
99 /* We'll use the ENGINE's private digest definition */
102 * Store the ENGINE functional reference so we know 'type' came
103 * from an ENGINE and we need to release it when done.
110 EVPerr(EVP_F_EVP_DIGESTINIT_EX, EVP_R_NO_DIGEST_SET);
116 if (ctx->digest != type) {
117 if (ctx->digest && ctx->digest->ctx_size) {
118 OPENSSL_clear_free(ctx->md_data, ctx->digest->ctx_size);
122 if (!(ctx->flags & EVP_MD_CTX_FLAG_NO_INIT) && type->ctx_size) {
123 ctx->update = type->update;
124 ctx->md_data = OPENSSL_zalloc(type->ctx_size);
125 if (ctx->md_data == NULL) {
126 EVPerr(EVP_F_EVP_DIGESTINIT_EX, ERR_R_MALLOC_FAILURE);
131 #ifndef OPENSSL_NO_ENGINE
136 r = EVP_PKEY_CTX_ctrl(ctx->pctx, -1, EVP_PKEY_OP_TYPE_SIG,
137 EVP_PKEY_CTRL_DIGESTINIT, 0, ctx);
138 if (r <= 0 && (r != -2))
141 if (ctx->flags & EVP_MD_CTX_FLAG_NO_INIT)
143 return ctx->digest->init(ctx);
146 int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t count)
148 return ctx->update(ctx, data, count);
151 /* The caller can assume that this removes any secret data from the context */
152 int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
155 ret = EVP_DigestFinal_ex(ctx, md, size);
156 EVP_MD_CTX_reset(ctx);
160 /* The caller can assume that this removes any secret data from the context */
161 int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
165 OPENSSL_assert(ctx->digest->md_size <= EVP_MAX_MD_SIZE);
166 ret = ctx->digest->final(ctx, md);
168 *size = ctx->digest->md_size;
169 if (ctx->digest->cleanup) {
170 ctx->digest->cleanup(ctx);
171 EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_CLEANED);
173 OPENSSL_cleanse(ctx->md_data, ctx->digest->ctx_size);
177 int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in)
179 EVP_MD_CTX_reset(out);
180 return EVP_MD_CTX_copy_ex(out, in);
183 int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in)
185 unsigned char *tmp_buf;
186 if ((in == NULL) || (in->digest == NULL)) {
187 EVPerr(EVP_F_EVP_MD_CTX_COPY_EX, EVP_R_INPUT_NOT_INITIALIZED);
190 #ifndef OPENSSL_NO_ENGINE
191 /* Make sure it's safe to copy a digest context using an ENGINE */
192 if (in->engine && !ENGINE_init(in->engine)) {
193 EVPerr(EVP_F_EVP_MD_CTX_COPY_EX, ERR_R_ENGINE_LIB);
198 if (out->digest == in->digest) {
199 tmp_buf = out->md_data;
200 EVP_MD_CTX_set_flags(out, EVP_MD_CTX_FLAG_REUSE);
203 EVP_MD_CTX_reset(out);
204 memcpy(out, in, sizeof(*out));
206 /* Null these variables, since they are getting fixed up
207 * properly below. Anything else may cause a memleak and/or
208 * double free if any of the memory allocations below fail
213 if (in->md_data && out->digest->ctx_size) {
215 out->md_data = tmp_buf;
217 out->md_data = OPENSSL_malloc(out->digest->ctx_size);
218 if (out->md_data == NULL) {
219 EVPerr(EVP_F_EVP_MD_CTX_COPY_EX, ERR_R_MALLOC_FAILURE);
223 memcpy(out->md_data, in->md_data, out->digest->ctx_size);
226 out->update = in->update;
229 out->pctx = EVP_PKEY_CTX_dup(in->pctx);
231 EVP_MD_CTX_reset(out);
236 if (out->digest->copy)
237 return out->digest->copy(out, in);
242 int EVP_Digest(const void *data, size_t count,
243 unsigned char *md, unsigned int *size, const EVP_MD *type,
246 EVP_MD_CTX *ctx = EVP_MD_CTX_new();
251 EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_ONESHOT);
252 ret = EVP_DigestInit_ex(ctx, type, impl)
253 && EVP_DigestUpdate(ctx, data, count)
254 && EVP_DigestFinal_ex(ctx, md, size);
255 EVP_MD_CTX_free(ctx);
260 int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2)
262 if (ctx->digest && ctx->digest->md_ctrl) {
263 int ret = ctx->digest->md_ctrl(ctx, cmd, p1, p2);