Debian Codegraph @

external/boringssl/crypto/digest/digest.c

raw
1 /* Copyright (C) 1995-1998 Eric Young ([email protected])
2 * All rights reserved.
3 *
4 * This package is an SSL implementation written
5 * by Eric Young ([email protected]).
6 * The implementation was written so as to conform with Netscapes SSL.
7 *
8 * This library is free for commercial and non-commercial use as long as
9 * the following conditions are aheared to. The following conditions
10 * apply to all code found in this distribution, be it the RC4, RSA,
11 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
12 * included with this distribution is covered by the same copyright terms
13 * except that the holder is Tim Hudson ([email protected]).
14 *
15 * Copyright remains Eric Young's, and as such any Copyright notices in
16 * the code are not to be removed.
17 * If this package is used in a product, Eric Young should be given attribution
18 * as the author of the parts of the library used.
19 * This can be in the form of a textual message at program startup or
20 * in documentation (online or textual) provided with the package.
21 *
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
24 * are met:
25 * 1. Redistributions of source code must retain the copyright
26 * notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution.
30 * 3. All advertising materials mentioning features or use of this software
31 * must display the following acknowledgement:
32 * "This product includes cryptographic software written by
33 * Eric Young ([email protected])"
34 * The word 'cryptographic' can be left out if the rouines from the library
35 * being used are not cryptographic related :-).
36 * 4. If you include any Windows specific code (or a derivative thereof) from
37 * the apps directory (application code) you must include an acknowledgement:
38 * "This product includes software written by Tim Hudson ([email protected])"
39 *
40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50 * SUCH DAMAGE.
51 *
52 * The licence and distribution terms for any publically available version or
53 * derivative of this code cannot be changed. i.e. this code cannot simply be
54 * copied and put under another distribution licence
55 * [including the GNU Public Licence.] */
56
57 #include <openssl/digest.h>
58
59 #include <assert.h>
60 #include <string.h>
61
62 #include <openssl/err.h>
63 #include <openssl/mem.h>
64
65 #include "internal.h"
66
67
68 int EVP_MD_type(const EVP_MD *md) { return md->type; }
69
70 uint32_t EVP_MD_flags(const EVP_MD *md) { return md->flags; }
71
72 size_t EVP_MD_size(const EVP_MD *md) { return md->md_size; }
73
74 size_t EVP_MD_block_size(const EVP_MD *md) { return md->block_size; }
75
76
77 void EVP_MD_CTX_init(EVP_MD_CTX *ctx) { memset(ctx, 0, sizeof(EVP_MD_CTX)); }
78
79 EVP_MD_CTX *EVP_MD_CTX_create(void) {
80 EVP_MD_CTX *ctx = OPENSSL_malloc(sizeof(EVP_MD_CTX));
81
82 if (ctx) {
83 EVP_MD_CTX_init(ctx);
84 }
85
86 return ctx;
87 }
88
89 int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx) {
90 if (ctx->digest && ctx->digest->ctx_size && ctx->md_data) {
91 OPENSSL_cleanse(ctx->md_data, ctx->digest->ctx_size);
92 OPENSSL_free(ctx->md_data);
93 }
94
95 assert(ctx->pctx == NULL || ctx->pctx_ops != NULL);
96 if (ctx->pctx_ops) {
97 ctx->pctx_ops->free(ctx->pctx);
98 }
99
100 EVP_MD_CTX_init(ctx);
101
102 return 1;
103 }
104
105 void EVP_MD_CTX_destroy(EVP_MD_CTX *ctx) {
106 if (!ctx) {
107 return;
108 }
109
110 EVP_MD_CTX_cleanup(ctx);
111 OPENSSL_free(ctx);
112 }
113
114 int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in) {
115 uint8_t *tmp_buf = NULL;
116
117 if (in == NULL || in->digest == NULL) {
118 OPENSSL_PUT_ERROR(DIGEST, DIGEST_R_INPUT_NOT_INITIALIZED);
119 return 0;
120 }
121
122 if (out->digest == in->digest) {
123 /* |md_data| will be the correct size in this case so it's removed from
124 * |out| at this point so that |EVP_MD_CTX_cleanup| doesn't free it and
125 * then it's reused. */
126 tmp_buf = out->md_data;
127 out->md_data = NULL;
128 }
129
130 EVP_MD_CTX_cleanup(out);
131
132 out->digest = in->digest;
133 if (in->md_data && in->digest->ctx_size) {
134 if (tmp_buf) {
135 out->md_data = tmp_buf;
136 } else {
137 out->md_data = OPENSSL_malloc(in->digest->ctx_size);
138 if (!out->md_data) {
139 OPENSSL_PUT_ERROR(DIGEST, ERR_R_MALLOC_FAILURE);
140 return 0;
141 }
142 }
143 memcpy(out->md_data, in->md_data, in->digest->ctx_size);
144 }
145
146 assert(in->pctx == NULL || in->pctx_ops != NULL);
147 out->pctx_ops = in->pctx_ops;
148 if (in->pctx && in->pctx_ops) {
149 out->pctx = in->pctx_ops->dup(in->pctx);
150 if (!out->pctx) {
151 EVP_MD_CTX_cleanup(out);
152 return 0;
153 }
154 }
155
156 return 1;
157 }
158
159 int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in) {
160 EVP_MD_CTX_init(out);
161 return EVP_MD_CTX_copy_ex(out, in);
162 }
163
164 int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *engine) {
165 if (ctx->digest != type) {
166 if (ctx->digest && ctx->digest->ctx_size > 0) {
167 OPENSSL_free(ctx->md_data);
168 ctx->md_data = NULL;
169 }
170 ctx->digest = type;
171 if (type->ctx_size > 0) {
172 ctx->md_data = OPENSSL_malloc(type->ctx_size);
173 if (ctx->md_data == NULL) {
174 OPENSSL_PUT_ERROR(DIGEST, ERR_R_MALLOC_FAILURE);
175 return 0;
176 }
177 }
178 }
179
180 assert(ctx->pctx == NULL || ctx->pctx_ops != NULL);
181
182 ctx->digest->init(ctx);
183 return 1;
184 }
185
186 int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type) {
187 EVP_MD_CTX_init(ctx);
188 return EVP_DigestInit_ex(ctx, type, NULL);
189 }
190
191 int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t len) {
192 ctx->digest->update(ctx, data, len);
193 return 1;
194 }
195
196 int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, uint8_t *md_out, unsigned int *size) {
197 assert(ctx->digest->md_size <= EVP_MAX_MD_SIZE);
198 ctx->digest->final(ctx, md_out);
199 if (size != NULL) {
200 *size = ctx->digest->md_size;
201 }
202 OPENSSL_cleanse(ctx->md_data, ctx->digest->ctx_size);
203 return 1;
204 }
205
206 int EVP_DigestFinal(EVP_MD_CTX *ctx, uint8_t *md, unsigned int *size) {
207 (void)EVP_DigestFinal_ex(ctx, md, size);
208 EVP_MD_CTX_cleanup(ctx);
209 return 1;
210 }
211
212 int EVP_Digest(const void *data, size_t count, uint8_t *out_md,
213 unsigned int *out_size, const EVP_MD *type, ENGINE *impl) {
214 EVP_MD_CTX ctx;
215 int ret;
216
217 EVP_MD_CTX_init(&ctx);
218 ret = EVP_DigestInit_ex(&ctx, type, impl) &&
219 EVP_DigestUpdate(&ctx, data, count) &&
220 EVP_DigestFinal_ex(&ctx, out_md, out_size);
221 EVP_MD_CTX_cleanup(&ctx);
222
223 return ret;
224 }
225
226
227 const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx) {
228 if (ctx == NULL) {
229 return NULL;
230 }
231 return ctx->digest;
232 }
233
234 size_t EVP_MD_CTX_size(const EVP_MD_CTX *ctx) {
235 return EVP_MD_size(EVP_MD_CTX_md(ctx));
236 }
237
238 size_t EVP_MD_CTX_block_size(const EVP_MD_CTX *ctx) {
239 return EVP_MD_block_size(EVP_MD_CTX_md(ctx));
240 }
241
242 int EVP_MD_CTX_type(const EVP_MD_CTX *ctx) {
243 return EVP_MD_type(EVP_MD_CTX_md(ctx));
244 }
245
246 int EVP_add_digest(const EVP_MD *digest) {
247 return 1;
248 }