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_DigestFinalXOF(EVP_MD_CTX
*ctx
, unsigned char *md
, size_t size
)
181 if (ctx
->digest
->flags
& EVP_MD_FLAG_XOF
183 && ctx
->digest
->md_ctrl(ctx
, EVP_MD_CTRL_XOF_LEN
, (int)size
, NULL
)) {
184 ret
= ctx
->digest
->final(ctx
, md
);
186 if (ctx
->digest
->cleanup
!= NULL
) {
187 ctx
->digest
->cleanup(ctx
);
188 EVP_MD_CTX_set_flags(ctx
, EVP_MD_CTX_FLAG_CLEANED
);
190 OPENSSL_cleanse(ctx
->md_data
, ctx
->digest
->ctx_size
);
192 EVPerr(EVP_F_EVP_DIGESTFINALXOF
, EVP_R_NOT_XOF_OR_INVALID_LENGTH
);
198 int EVP_MD_CTX_copy(EVP_MD_CTX
*out
, const EVP_MD_CTX
*in
)
200 EVP_MD_CTX_reset(out
);
201 return EVP_MD_CTX_copy_ex(out
, in
);
204 int EVP_MD_CTX_copy_ex(EVP_MD_CTX
*out
, const EVP_MD_CTX
*in
)
206 unsigned char *tmp_buf
;
207 if ((in
== NULL
) || (in
->digest
== NULL
)) {
208 EVPerr(EVP_F_EVP_MD_CTX_COPY_EX
, EVP_R_INPUT_NOT_INITIALIZED
);
211 #ifndef OPENSSL_NO_ENGINE
212 /* Make sure it's safe to copy a digest context using an ENGINE */
213 if (in
->engine
&& !ENGINE_init(in
->engine
)) {
214 EVPerr(EVP_F_EVP_MD_CTX_COPY_EX
, ERR_R_ENGINE_LIB
);
219 if (out
->digest
== in
->digest
) {
220 tmp_buf
= out
->md_data
;
221 EVP_MD_CTX_set_flags(out
, EVP_MD_CTX_FLAG_REUSE
);
224 EVP_MD_CTX_reset(out
);
225 memcpy(out
, in
, sizeof(*out
));
227 /* Null these variables, since they are getting fixed up
228 * properly below. Anything else may cause a memleak and/or
229 * double free if any of the memory allocations below fail
234 if (in
->md_data
&& out
->digest
->ctx_size
) {
236 out
->md_data
= tmp_buf
;
238 out
->md_data
= OPENSSL_malloc(out
->digest
->ctx_size
);
239 if (out
->md_data
== NULL
) {
240 EVPerr(EVP_F_EVP_MD_CTX_COPY_EX
, ERR_R_MALLOC_FAILURE
);
244 memcpy(out
->md_data
, in
->md_data
, out
->digest
->ctx_size
);
247 out
->update
= in
->update
;
250 out
->pctx
= EVP_PKEY_CTX_dup(in
->pctx
);
252 EVP_MD_CTX_reset(out
);
257 if (out
->digest
->copy
)
258 return out
->digest
->copy(out
, in
);
263 int EVP_Digest(const void *data
, size_t count
,
264 unsigned char *md
, unsigned int *size
, const EVP_MD
*type
,
267 EVP_MD_CTX
*ctx
= EVP_MD_CTX_new();
272 EVP_MD_CTX_set_flags(ctx
, EVP_MD_CTX_FLAG_ONESHOT
);
273 ret
= EVP_DigestInit_ex(ctx
, type
, impl
)
274 && EVP_DigestUpdate(ctx
, data
, count
)
275 && EVP_DigestFinal_ex(ctx
, md
, size
);
276 EVP_MD_CTX_free(ctx
);
281 int EVP_MD_CTX_ctrl(EVP_MD_CTX
*ctx
, int cmd
, int p1
, void *p2
)
283 if (ctx
->digest
&& ctx
->digest
->md_ctrl
) {
284 int ret
= ctx
->digest
->md_ctrl(ctx
, cmd
, p1
, p2
);