1 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
---|---|
2 | * All rights reserved. |
3 | * |
4 | * This package is an SSL implementation written |
5 | * by Eric Young (eay@cryptsoft.com). |
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 (tjh@cryptsoft.com). |
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 (eay@cryptsoft.com)" |
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 (tjh@cryptsoft.com)" |
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 | #include "../../internal.h" |
67 | |
68 | |
69 | int EVP_MD_type(const EVP_MD *md) { return md->type; } |
70 | |
71 | int EVP_MD_nid(const EVP_MD *md) { return EVP_MD_type(md); } |
72 | |
73 | uint32_t EVP_MD_flags(const EVP_MD *md) { return md->flags; } |
74 | |
75 | size_t EVP_MD_size(const EVP_MD *md) { return md->md_size; } |
76 | |
77 | size_t EVP_MD_block_size(const EVP_MD *md) { return md->block_size; } |
78 | |
79 | |
80 | void EVP_MD_CTX_init(EVP_MD_CTX *ctx) { |
81 | OPENSSL_memset(dst: ctx, c: 0, n: sizeof(EVP_MD_CTX)); |
82 | } |
83 | |
84 | EVP_MD_CTX *EVP_MD_CTX_new(void) { |
85 | EVP_MD_CTX *ctx = OPENSSL_malloc(size: sizeof(EVP_MD_CTX)); |
86 | |
87 | if (ctx) { |
88 | EVP_MD_CTX_init(ctx); |
89 | } |
90 | |
91 | return ctx; |
92 | } |
93 | |
94 | EVP_MD_CTX *EVP_MD_CTX_create(void) { return EVP_MD_CTX_new(); } |
95 | |
96 | int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx) { |
97 | OPENSSL_free(ptr: ctx->md_data); |
98 | |
99 | assert(ctx->pctx == NULL || ctx->pctx_ops != NULL); |
100 | if (ctx->pctx_ops) { |
101 | ctx->pctx_ops->free(ctx->pctx); |
102 | } |
103 | |
104 | EVP_MD_CTX_init(ctx); |
105 | |
106 | return 1; |
107 | } |
108 | |
109 | void EVP_MD_CTX_cleanse(EVP_MD_CTX *ctx) { |
110 | OPENSSL_cleanse(ptr: ctx->md_data, len: ctx->digest->ctx_size); |
111 | EVP_MD_CTX_cleanup(ctx); |
112 | } |
113 | |
114 | void EVP_MD_CTX_free(EVP_MD_CTX *ctx) { |
115 | if (!ctx) { |
116 | return; |
117 | } |
118 | |
119 | EVP_MD_CTX_cleanup(ctx); |
120 | OPENSSL_free(ptr: ctx); |
121 | } |
122 | |
123 | void EVP_MD_CTX_destroy(EVP_MD_CTX *ctx) { EVP_MD_CTX_free(ctx); } |
124 | |
125 | int EVP_DigestFinalXOF(EVP_MD_CTX *ctx, uint8_t *out, size_t len) { |
126 | OPENSSL_PUT_ERROR(DIGEST, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); |
127 | return 0; |
128 | } |
129 | |
130 | uint32_t EVP_MD_meth_get_flags(const EVP_MD *md) { return EVP_MD_flags(md); } |
131 | |
132 | void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags) {} |
133 | |
134 | int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in) { |
135 | // |in->digest| may be NULL if this is a signing |EVP_MD_CTX| for, e.g., |
136 | // Ed25519 which does not hash with |EVP_MD_CTX|. |
137 | if (in == NULL || (in->pctx == NULL && in->digest == NULL)) { |
138 | OPENSSL_PUT_ERROR(DIGEST, DIGEST_R_INPUT_NOT_INITIALIZED); |
139 | return 0; |
140 | } |
141 | |
142 | EVP_PKEY_CTX *pctx = NULL; |
143 | assert(in->pctx == NULL || in->pctx_ops != NULL); |
144 | if (in->pctx) { |
145 | pctx = in->pctx_ops->dup(in->pctx); |
146 | if (!pctx) { |
147 | return 0; |
148 | } |
149 | } |
150 | |
151 | uint8_t *tmp_buf = NULL; |
152 | if (in->digest != NULL) { |
153 | if (out->digest != in->digest) { |
154 | assert(in->digest->ctx_size != 0); |
155 | tmp_buf = OPENSSL_malloc(size: in->digest->ctx_size); |
156 | if (tmp_buf == NULL) { |
157 | if (pctx) { |
158 | in->pctx_ops->free(pctx); |
159 | } |
160 | return 0; |
161 | } |
162 | } else { |
163 | // |md_data| will be the correct size in this case. It's removed from |
164 | // |out| so that |EVP_MD_CTX_cleanup| doesn't free it, and then it's |
165 | // reused. |
166 | tmp_buf = out->md_data; |
167 | out->md_data = NULL; |
168 | } |
169 | } |
170 | |
171 | EVP_MD_CTX_cleanup(ctx: out); |
172 | |
173 | out->digest = in->digest; |
174 | out->md_data = tmp_buf; |
175 | if (in->digest != NULL) { |
176 | OPENSSL_memcpy(dst: out->md_data, src: in->md_data, n: in->digest->ctx_size); |
177 | } |
178 | out->pctx = pctx; |
179 | out->pctx_ops = in->pctx_ops; |
180 | assert(out->pctx == NULL || out->pctx_ops != NULL); |
181 | |
182 | return 1; |
183 | } |
184 | |
185 | void EVP_MD_CTX_move(EVP_MD_CTX *out, EVP_MD_CTX *in) { |
186 | EVP_MD_CTX_cleanup(ctx: out); |
187 | // While not guaranteed, |EVP_MD_CTX| is currently safe to move with |memcpy|. |
188 | OPENSSL_memcpy(dst: out, src: in, n: sizeof(EVP_MD_CTX)); |
189 | EVP_MD_CTX_init(ctx: in); |
190 | } |
191 | |
192 | int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in) { |
193 | EVP_MD_CTX_init(ctx: out); |
194 | return EVP_MD_CTX_copy_ex(out, in); |
195 | } |
196 | |
197 | int EVP_MD_CTX_reset(EVP_MD_CTX *ctx) { |
198 | EVP_MD_CTX_cleanup(ctx); |
199 | EVP_MD_CTX_init(ctx); |
200 | return 1; |
201 | } |
202 | |
203 | int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *engine) { |
204 | if (ctx->digest != type) { |
205 | assert(type->ctx_size != 0); |
206 | uint8_t *md_data = OPENSSL_malloc(size: type->ctx_size); |
207 | if (md_data == NULL) { |
208 | return 0; |
209 | } |
210 | |
211 | OPENSSL_free(ptr: ctx->md_data); |
212 | ctx->md_data = md_data; |
213 | ctx->digest = type; |
214 | } |
215 | |
216 | assert(ctx->pctx == NULL || ctx->pctx_ops != NULL); |
217 | |
218 | ctx->digest->init(ctx); |
219 | return 1; |
220 | } |
221 | |
222 | int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type) { |
223 | EVP_MD_CTX_init(ctx); |
224 | return EVP_DigestInit_ex(ctx, type, NULL); |
225 | } |
226 | |
227 | int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t len) { |
228 | ctx->digest->update(ctx, data, len); |
229 | return 1; |
230 | } |
231 | |
232 | int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, uint8_t *md_out, unsigned int *size) { |
233 | assert(ctx->digest->md_size <= EVP_MAX_MD_SIZE); |
234 | ctx->digest->final(ctx, md_out); |
235 | if (size != NULL) { |
236 | *size = ctx->digest->md_size; |
237 | } |
238 | OPENSSL_cleanse(ptr: ctx->md_data, len: ctx->digest->ctx_size); |
239 | return 1; |
240 | } |
241 | |
242 | int EVP_DigestFinal(EVP_MD_CTX *ctx, uint8_t *md, unsigned int *size) { |
243 | (void)EVP_DigestFinal_ex(ctx, md_out: md, size); |
244 | EVP_MD_CTX_cleanup(ctx); |
245 | return 1; |
246 | } |
247 | |
248 | int EVP_Digest(const void *data, size_t count, uint8_t *out_md, |
249 | unsigned int *out_size, const EVP_MD *type, ENGINE *impl) { |
250 | EVP_MD_CTX ctx; |
251 | int ret; |
252 | |
253 | EVP_MD_CTX_init(ctx: &ctx); |
254 | ret = EVP_DigestInit_ex(ctx: &ctx, type, engine: impl) && |
255 | EVP_DigestUpdate(ctx: &ctx, data, len: count) && |
256 | EVP_DigestFinal_ex(ctx: &ctx, md_out: out_md, size: out_size); |
257 | EVP_MD_CTX_cleanup(ctx: &ctx); |
258 | |
259 | return ret; |
260 | } |
261 | |
262 | |
263 | const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx) { |
264 | if (ctx == NULL) { |
265 | return NULL; |
266 | } |
267 | return ctx->digest; |
268 | } |
269 | |
270 | size_t EVP_MD_CTX_size(const EVP_MD_CTX *ctx) { |
271 | return EVP_MD_size(md: EVP_MD_CTX_md(ctx)); |
272 | } |
273 | |
274 | size_t EVP_MD_CTX_block_size(const EVP_MD_CTX *ctx) { |
275 | return EVP_MD_block_size(md: EVP_MD_CTX_md(ctx)); |
276 | } |
277 | |
278 | int EVP_MD_CTX_type(const EVP_MD_CTX *ctx) { |
279 | return EVP_MD_type(md: EVP_MD_CTX_md(ctx)); |
280 | } |
281 | |
282 | int EVP_add_digest(const EVP_MD *digest) { |
283 | return 1; |
284 | } |
285 |
Definitions
- EVP_MD_type
- EVP_MD_nid
- EVP_MD_flags
- EVP_MD_size
- EVP_MD_block_size
- EVP_MD_CTX_init
- EVP_MD_CTX_new
- EVP_MD_CTX_create
- EVP_MD_CTX_cleanup
- EVP_MD_CTX_cleanse
- EVP_MD_CTX_free
- EVP_MD_CTX_destroy
- EVP_DigestFinalXOF
- EVP_MD_meth_get_flags
- EVP_MD_CTX_set_flags
- EVP_MD_CTX_copy_ex
- EVP_MD_CTX_move
- EVP_MD_CTX_copy
- EVP_MD_CTX_reset
- EVP_DigestInit_ex
- EVP_DigestInit
- EVP_DigestUpdate
- EVP_DigestFinal_ex
- EVP_DigestFinal
- EVP_Digest
- EVP_MD_CTX_md
- EVP_MD_CTX_size
- EVP_MD_CTX_block_size
- EVP_MD_CTX_type
Learn more about Flutter for embedded and desktop on industrialflutter.com