Branch data Line data Source code
1 : : /*
2 : : * This file is part of the MicroPython project, http://micropython.org/
3 : : *
4 : : * The MIT License (MIT)
5 : : *
6 : : * Copyright (c) 2014 Paul Sokolovsky
7 : : *
8 : : * Permission is hereby granted, free of charge, to any person obtaining a copy
9 : : * of this software and associated documentation files (the "Software"), to deal
10 : : * in the Software without restriction, including without limitation the rights
11 : : * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 : : * copies of the Software, and to permit persons to whom the Software is
13 : : * furnished to do so, subject to the following conditions:
14 : : *
15 : : * The above copyright notice and this permission notice shall be included in
16 : : * all copies or substantial portions of the Software.
17 : : *
18 : : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 : : * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 : : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 : : * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 : : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 : : * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 : : * THE SOFTWARE.
25 : : */
26 : :
27 : : #include <assert.h>
28 : : #include <string.h>
29 : :
30 : : #include "py/runtime.h"
31 : :
32 : : #if MICROPY_PY_HASHLIB
33 : :
34 : : #if MICROPY_SSL_MBEDTLS
35 : : #include "mbedtls/version.h"
36 : : #endif
37 : :
38 : : #if MICROPY_PY_HASHLIB_SHA256
39 : :
40 : : #if MICROPY_SSL_MBEDTLS
41 : : #include "mbedtls/sha256.h"
42 : : #else
43 : : #include "lib/crypto-algorithms/sha256.h"
44 : : #endif
45 : :
46 : : #endif
47 : :
48 : : #if MICROPY_PY_HASHLIB_SHA1 || MICROPY_PY_HASHLIB_MD5
49 : :
50 : : #if MICROPY_SSL_AXTLS
51 : : #include "lib/axtls/crypto/crypto.h"
52 : : #endif
53 : :
54 : : #if MICROPY_SSL_MBEDTLS
55 : : #include "mbedtls/md5.h"
56 : : #include "mbedtls/sha1.h"
57 : : #endif
58 : :
59 : : #endif
60 : :
61 : : typedef struct _mp_obj_hash_t {
62 : : mp_obj_base_t base;
63 : : bool final; // if set, update and digest raise an exception
64 : : uintptr_t state[0]; // must be aligned to a machine word
65 : : } mp_obj_hash_t;
66 : :
67 : 66 : static void hashlib_ensure_not_final(mp_obj_hash_t *self) {
68 [ + + ]: 66 : if (self->final) {
69 : 12 : mp_raise_ValueError(MP_ERROR_TEXT("hash is final"));
70 : : }
71 : 54 : }
72 : :
73 : : #if MICROPY_PY_HASHLIB_SHA256
74 : : static mp_obj_t hashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg);
75 : :
76 : : #if MICROPY_SSL_MBEDTLS
77 : :
78 : : #if MBEDTLS_VERSION_NUMBER < 0x02070000 || MBEDTLS_VERSION_NUMBER >= 0x03000000
79 : : #define mbedtls_sha256_starts_ret mbedtls_sha256_starts
80 : : #define mbedtls_sha256_update_ret mbedtls_sha256_update
81 : : #define mbedtls_sha256_finish_ret mbedtls_sha256_finish
82 : : #endif
83 : :
84 : 14 : static mp_obj_t hashlib_sha256_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
85 : 14 : mp_arg_check_num(n_args, n_kw, 0, 1, false);
86 : 14 : mp_obj_hash_t *o = mp_obj_malloc_var(mp_obj_hash_t, state, char, sizeof(mbedtls_sha256_context), type);
87 : 14 : o->final = false;
88 : 14 : mbedtls_sha256_init((mbedtls_sha256_context *)&o->state);
89 : 14 : mbedtls_sha256_starts_ret((mbedtls_sha256_context *)&o->state, 0);
90 [ + + ]: 14 : if (n_args == 1) {
91 : 8 : hashlib_sha256_update(MP_OBJ_FROM_PTR(o), args[0]);
92 : : }
93 : 14 : return MP_OBJ_FROM_PTR(o);
94 : : }
95 : :
96 : 14 : static mp_obj_t hashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg) {
97 : 14 : mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
98 : 14 : hashlib_ensure_not_final(self);
99 : 12 : mp_buffer_info_t bufinfo;
100 : 12 : mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
101 : 12 : mbedtls_sha256_update_ret((mbedtls_sha256_context *)&self->state, bufinfo.buf, bufinfo.len);
102 : 12 : return mp_const_none;
103 : : }
104 : :
105 : 16 : static mp_obj_t hashlib_sha256_digest(mp_obj_t self_in) {
106 : 16 : mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
107 : 16 : hashlib_ensure_not_final(self);
108 : 14 : self->final = true;
109 : 14 : vstr_t vstr;
110 : 14 : vstr_init_len(&vstr, 32);
111 : 14 : mbedtls_sha256_finish_ret((mbedtls_sha256_context *)&self->state, (unsigned char *)vstr.buf);
112 : 14 : return mp_obj_new_bytes_from_vstr(&vstr);
113 : : }
114 : :
115 : : #else
116 : :
117 : : #include "lib/crypto-algorithms/sha256.c"
118 : :
119 : : static mp_obj_t hashlib_sha256_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
120 : : mp_arg_check_num(n_args, n_kw, 0, 1, false);
121 : : mp_obj_hash_t *o = mp_obj_malloc_var(mp_obj_hash_t, state, char, sizeof(CRYAL_SHA256_CTX), type);
122 : : o->final = false;
123 : : sha256_init((CRYAL_SHA256_CTX *)o->state);
124 : : if (n_args == 1) {
125 : : hashlib_sha256_update(MP_OBJ_FROM_PTR(o), args[0]);
126 : : }
127 : : return MP_OBJ_FROM_PTR(o);
128 : : }
129 : :
130 : : static mp_obj_t hashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg) {
131 : : mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
132 : : hashlib_ensure_not_final(self);
133 : : mp_buffer_info_t bufinfo;
134 : : mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
135 : : sha256_update((CRYAL_SHA256_CTX *)self->state, bufinfo.buf, bufinfo.len);
136 : : return mp_const_none;
137 : : }
138 : :
139 : : static mp_obj_t hashlib_sha256_digest(mp_obj_t self_in) {
140 : : mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
141 : : hashlib_ensure_not_final(self);
142 : : self->final = true;
143 : : vstr_t vstr;
144 : : vstr_init_len(&vstr, SHA256_BLOCK_SIZE);
145 : : sha256_final((CRYAL_SHA256_CTX *)self->state, (byte *)vstr.buf);
146 : : return mp_obj_new_bytes_from_vstr(&vstr);
147 : : }
148 : : #endif
149 : :
150 : : static MP_DEFINE_CONST_FUN_OBJ_2(hashlib_sha256_update_obj, hashlib_sha256_update);
151 : : static MP_DEFINE_CONST_FUN_OBJ_1(hashlib_sha256_digest_obj, hashlib_sha256_digest);
152 : :
153 : : static const mp_rom_map_elem_t hashlib_sha256_locals_dict_table[] = {
154 : : { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&hashlib_sha256_update_obj) },
155 : : { MP_ROM_QSTR(MP_QSTR_digest), MP_ROM_PTR(&hashlib_sha256_digest_obj) },
156 : : };
157 : :
158 : : static MP_DEFINE_CONST_DICT(hashlib_sha256_locals_dict, hashlib_sha256_locals_dict_table);
159 : :
160 : : static MP_DEFINE_CONST_OBJ_TYPE(
161 : : hashlib_sha256_type,
162 : : MP_QSTR_sha256,
163 : : MP_TYPE_FLAG_NONE,
164 : : make_new, hashlib_sha256_make_new,
165 : : locals_dict, &hashlib_sha256_locals_dict
166 : : );
167 : : #endif
168 : :
169 : : #if MICROPY_PY_HASHLIB_SHA1
170 : : static mp_obj_t hashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg);
171 : :
172 : : #if MICROPY_SSL_AXTLS
173 : : static mp_obj_t hashlib_sha1_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
174 : : mp_arg_check_num(n_args, n_kw, 0, 1, false);
175 : : mp_obj_hash_t *o = mp_obj_malloc_var(mp_obj_hash_t, state, char, sizeof(SHA1_CTX), type);
176 : : o->final = false;
177 : : SHA1_Init((SHA1_CTX *)o->state);
178 : : if (n_args == 1) {
179 : : hashlib_sha1_update(MP_OBJ_FROM_PTR(o), args[0]);
180 : : }
181 : : return MP_OBJ_FROM_PTR(o);
182 : : }
183 : :
184 : : static mp_obj_t hashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg) {
185 : : mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
186 : : hashlib_ensure_not_final(self);
187 : : mp_buffer_info_t bufinfo;
188 : : mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
189 : : SHA1_Update((SHA1_CTX *)self->state, bufinfo.buf, bufinfo.len);
190 : : return mp_const_none;
191 : : }
192 : :
193 : : static mp_obj_t hashlib_sha1_digest(mp_obj_t self_in) {
194 : : mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
195 : : hashlib_ensure_not_final(self);
196 : : self->final = true;
197 : : vstr_t vstr;
198 : : vstr_init_len(&vstr, SHA1_SIZE);
199 : : SHA1_Final((byte *)vstr.buf, (SHA1_CTX *)self->state);
200 : : return mp_obj_new_bytes_from_vstr(&vstr);
201 : : }
202 : : #endif
203 : :
204 : : #if MICROPY_SSL_MBEDTLS
205 : :
206 : : #if MBEDTLS_VERSION_NUMBER < 0x02070000 || MBEDTLS_VERSION_NUMBER >= 0x03000000
207 : : #define mbedtls_sha1_starts_ret mbedtls_sha1_starts
208 : : #define mbedtls_sha1_update_ret mbedtls_sha1_update
209 : : #define mbedtls_sha1_finish_ret mbedtls_sha1_finish
210 : : #endif
211 : :
212 : 6 : static mp_obj_t hashlib_sha1_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
213 : 6 : mp_arg_check_num(n_args, n_kw, 0, 1, false);
214 : 6 : mp_obj_hash_t *o = mp_obj_malloc_var(mp_obj_hash_t, state, char, sizeof(mbedtls_sha1_context), type);
215 : 6 : o->final = false;
216 : 6 : mbedtls_sha1_init((mbedtls_sha1_context *)o->state);
217 : 6 : mbedtls_sha1_starts_ret((mbedtls_sha1_context *)o->state);
218 [ + - ]: 6 : if (n_args == 1) {
219 : 6 : hashlib_sha1_update(MP_OBJ_FROM_PTR(o), args[0]);
220 : : }
221 : 6 : return MP_OBJ_FROM_PTR(o);
222 : : }
223 : :
224 : 10 : static mp_obj_t hashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg) {
225 : 10 : mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
226 : 10 : hashlib_ensure_not_final(self);
227 : 8 : mp_buffer_info_t bufinfo;
228 : 8 : mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
229 : 8 : mbedtls_sha1_update_ret((mbedtls_sha1_context *)self->state, bufinfo.buf, bufinfo.len);
230 : 8 : return mp_const_none;
231 : : }
232 : :
233 : 8 : static mp_obj_t hashlib_sha1_digest(mp_obj_t self_in) {
234 : 8 : mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
235 : 8 : hashlib_ensure_not_final(self);
236 : 6 : self->final = true;
237 : 6 : vstr_t vstr;
238 : 6 : vstr_init_len(&vstr, 20);
239 : 6 : mbedtls_sha1_finish_ret((mbedtls_sha1_context *)self->state, (byte *)vstr.buf);
240 : 6 : mbedtls_sha1_free((mbedtls_sha1_context *)self->state);
241 : 6 : return mp_obj_new_bytes_from_vstr(&vstr);
242 : : }
243 : : #endif
244 : :
245 : : static MP_DEFINE_CONST_FUN_OBJ_2(hashlib_sha1_update_obj, hashlib_sha1_update);
246 : : static MP_DEFINE_CONST_FUN_OBJ_1(hashlib_sha1_digest_obj, hashlib_sha1_digest);
247 : :
248 : : static const mp_rom_map_elem_t hashlib_sha1_locals_dict_table[] = {
249 : : { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&hashlib_sha1_update_obj) },
250 : : { MP_ROM_QSTR(MP_QSTR_digest), MP_ROM_PTR(&hashlib_sha1_digest_obj) },
251 : : };
252 : : static MP_DEFINE_CONST_DICT(hashlib_sha1_locals_dict, hashlib_sha1_locals_dict_table);
253 : :
254 : : static MP_DEFINE_CONST_OBJ_TYPE(
255 : : hashlib_sha1_type,
256 : : MP_QSTR_sha1,
257 : : MP_TYPE_FLAG_NONE,
258 : : make_new, hashlib_sha1_make_new,
259 : : locals_dict, &hashlib_sha1_locals_dict
260 : : );
261 : : #endif
262 : :
263 : : #if MICROPY_PY_HASHLIB_MD5
264 : : static mp_obj_t hashlib_md5_update(mp_obj_t self_in, mp_obj_t arg);
265 : :
266 : : #if MICROPY_SSL_AXTLS
267 : : static mp_obj_t hashlib_md5_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
268 : : mp_arg_check_num(n_args, n_kw, 0, 1, false);
269 : : mp_obj_hash_t *o = mp_obj_malloc_var(mp_obj_hash_t, state, char, sizeof(MD5_CTX), type);
270 : : o->final = false;
271 : : MD5_Init((MD5_CTX *)o->state);
272 : : if (n_args == 1) {
273 : : hashlib_md5_update(MP_OBJ_FROM_PTR(o), args[0]);
274 : : }
275 : : return MP_OBJ_FROM_PTR(o);
276 : : }
277 : :
278 : : static mp_obj_t hashlib_md5_update(mp_obj_t self_in, mp_obj_t arg) {
279 : : mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
280 : : hashlib_ensure_not_final(self);
281 : : mp_buffer_info_t bufinfo;
282 : : mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
283 : : MD5_Update((MD5_CTX *)self->state, bufinfo.buf, bufinfo.len);
284 : : return mp_const_none;
285 : : }
286 : :
287 : : static mp_obj_t hashlib_md5_digest(mp_obj_t self_in) {
288 : : mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
289 : : hashlib_ensure_not_final(self);
290 : : self->final = true;
291 : : vstr_t vstr;
292 : : vstr_init_len(&vstr, MD5_SIZE);
293 : : MD5_Final((byte *)vstr.buf, (MD5_CTX *)self->state);
294 : : return mp_obj_new_bytes_from_vstr(&vstr);
295 : : }
296 : : #endif // MICROPY_SSL_AXTLS
297 : :
298 : : #if MICROPY_SSL_MBEDTLS
299 : :
300 : : #if MBEDTLS_VERSION_NUMBER < 0x02070000 || MBEDTLS_VERSION_NUMBER >= 0x03000000
301 : : #define mbedtls_md5_starts_ret mbedtls_md5_starts
302 : : #define mbedtls_md5_update_ret mbedtls_md5_update
303 : : #define mbedtls_md5_finish_ret mbedtls_md5_finish
304 : : #endif
305 : :
306 : 6 : static mp_obj_t hashlib_md5_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
307 : 6 : mp_arg_check_num(n_args, n_kw, 0, 1, false);
308 : 6 : mp_obj_hash_t *o = mp_obj_malloc_var(mp_obj_hash_t, state, char, sizeof(mbedtls_md5_context), type);
309 : 6 : o->final = false;
310 : 6 : mbedtls_md5_init((mbedtls_md5_context *)o->state);
311 : 6 : mbedtls_md5_starts_ret((mbedtls_md5_context *)o->state);
312 [ + - ]: 6 : if (n_args == 1) {
313 : 6 : hashlib_md5_update(MP_OBJ_FROM_PTR(o), args[0]);
314 : : }
315 : 6 : return MP_OBJ_FROM_PTR(o);
316 : : }
317 : :
318 : 10 : static mp_obj_t hashlib_md5_update(mp_obj_t self_in, mp_obj_t arg) {
319 : 10 : mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
320 : 10 : hashlib_ensure_not_final(self);
321 : 8 : mp_buffer_info_t bufinfo;
322 : 8 : mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
323 : 8 : mbedtls_md5_update_ret((mbedtls_md5_context *)self->state, bufinfo.buf, bufinfo.len);
324 : 8 : return mp_const_none;
325 : : }
326 : :
327 : 8 : static mp_obj_t hashlib_md5_digest(mp_obj_t self_in) {
328 : 8 : mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
329 : 8 : hashlib_ensure_not_final(self);
330 : 6 : self->final = true;
331 : 6 : vstr_t vstr;
332 : 6 : vstr_init_len(&vstr, 16);
333 : 6 : mbedtls_md5_finish_ret((mbedtls_md5_context *)self->state, (byte *)vstr.buf);
334 : 6 : mbedtls_md5_free((mbedtls_md5_context *)self->state);
335 : 6 : return mp_obj_new_bytes_from_vstr(&vstr);
336 : : }
337 : : #endif // MICROPY_SSL_MBEDTLS
338 : :
339 : : static MP_DEFINE_CONST_FUN_OBJ_2(hashlib_md5_update_obj, hashlib_md5_update);
340 : : static MP_DEFINE_CONST_FUN_OBJ_1(hashlib_md5_digest_obj, hashlib_md5_digest);
341 : :
342 : : static const mp_rom_map_elem_t hashlib_md5_locals_dict_table[] = {
343 : : { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&hashlib_md5_update_obj) },
344 : : { MP_ROM_QSTR(MP_QSTR_digest), MP_ROM_PTR(&hashlib_md5_digest_obj) },
345 : : };
346 : : static MP_DEFINE_CONST_DICT(hashlib_md5_locals_dict, hashlib_md5_locals_dict_table);
347 : :
348 : : static MP_DEFINE_CONST_OBJ_TYPE(
349 : : hashlib_md5_type,
350 : : MP_QSTR_md5,
351 : : MP_TYPE_FLAG_NONE,
352 : : make_new, hashlib_md5_make_new,
353 : : locals_dict, &hashlib_md5_locals_dict
354 : : );
355 : : #endif // MICROPY_PY_HASHLIB_MD5
356 : :
357 : : static const mp_rom_map_elem_t mp_module_hashlib_globals_table[] = {
358 : : { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_hashlib) },
359 : : #if MICROPY_PY_HASHLIB_SHA256
360 : : { MP_ROM_QSTR(MP_QSTR_sha256), MP_ROM_PTR(&hashlib_sha256_type) },
361 : : #endif
362 : : #if MICROPY_PY_HASHLIB_SHA1
363 : : { MP_ROM_QSTR(MP_QSTR_sha1), MP_ROM_PTR(&hashlib_sha1_type) },
364 : : #endif
365 : : #if MICROPY_PY_HASHLIB_MD5
366 : : { MP_ROM_QSTR(MP_QSTR_md5), MP_ROM_PTR(&hashlib_md5_type) },
367 : : #endif
368 : : };
369 : :
370 : : static MP_DEFINE_CONST_DICT(mp_module_hashlib_globals, mp_module_hashlib_globals_table);
371 : :
372 : : const mp_obj_module_t mp_module_hashlib = {
373 : : .base = { &mp_type_module },
374 : : .globals = (mp_obj_dict_t *)&mp_module_hashlib_globals,
375 : : };
376 : :
377 : : MP_REGISTER_EXTENSIBLE_MODULE(MP_QSTR_hashlib, mp_module_hashlib);
378 : :
379 : : #endif // MICROPY_PY_HASHLIB
|
