PolarSSL v1.1.4
md_wrap.c
Go to the documentation of this file.
1 
30 #include "polarssl/config.h"
31 
32 #if defined(POLARSSL_MD_C)
33 
34 #include "polarssl/md_wrap.h"
35 #include "polarssl/md2.h"
36 #include "polarssl/md4.h"
37 #include "polarssl/md5.h"
38 #include "polarssl/sha1.h"
39 #include "polarssl/sha2.h"
40 #include "polarssl/sha4.h"
41 
42 #include <stdlib.h>
43 
44 #if defined(POLARSSL_MD2_C)
45 
46 static void md2_starts_wrap( void *ctx )
47 {
48  md2_starts( (md2_context *) ctx );
49 }
50 
51 static void md2_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
52 {
53  md2_update( (md2_context *) ctx, input, ilen );
54 }
55 
56 static void md2_finish_wrap( void *ctx, unsigned char *output )
57 {
58  md2_finish( (md2_context *) ctx, output );
59 }
60 
61 int md2_file_wrap( const char *path, unsigned char *output )
62 {
63 #if defined(POLARSSL_FS_IO)
64  return md2_file( path, output );
65 #else
66  ((void) path);
67  ((void) output);
69 #endif
70 }
71 
72 static void md2_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
73 {
74  md2_hmac_starts( (md2_context *) ctx, key, keylen );
75 }
76 
77 static void md2_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
78 {
79  md2_hmac_update( (md2_context *) ctx, input, ilen );
80 }
81 
82 static void md2_hmac_finish_wrap( void *ctx, unsigned char *output )
83 {
84  md2_hmac_finish( (md2_context *) ctx, output );
85 }
86 
87 static void md2_hmac_reset_wrap( void *ctx )
88 {
89  md2_hmac_reset( (md2_context *) ctx );
90 }
91 
92 static void * md2_ctx_alloc( void )
93 {
94  return malloc( sizeof( md2_context ) );
95 }
96 
97 static void md2_ctx_free( void *ctx )
98 {
99  free( ctx );
100 }
101 
102 const md_info_t md2_info = {
104  "MD2",
105  16,
106  md2_starts_wrap,
107  md2_update_wrap,
108  md2_finish_wrap,
109  md2,
110  md2_file_wrap,
111  md2_hmac_starts_wrap,
112  md2_hmac_update_wrap,
113  md2_hmac_finish_wrap,
114  md2_hmac_reset_wrap,
115  md2_hmac,
116  md2_ctx_alloc,
117  md2_ctx_free,
118 };
119 
120 #endif
121 
122 #if defined(POLARSSL_MD4_C)
123 
124 void md4_starts_wrap( void *ctx )
125 {
126  md4_starts( (md4_context *) ctx );
127 }
128 
129 void md4_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
130 {
131  md4_update( (md4_context *) ctx, input, ilen );
132 }
133 
134 void md4_finish_wrap( void *ctx, unsigned char *output )
135 {
136  md4_finish( (md4_context *) ctx, output );
137 }
138 
139 int md4_file_wrap( const char *path, unsigned char *output )
140 {
141 #if defined(POLARSSL_FS_IO)
142  return md4_file( path, output );
143 #else
144  ((void) path);
145  ((void) output);
147 #endif
148 }
149 
150 void md4_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
151 {
152  md4_hmac_starts( (md4_context *) ctx, key, keylen );
153 }
154 
155 void md4_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
156 {
157  md4_hmac_update( (md4_context *) ctx, input, ilen );
158 }
159 
160 void md4_hmac_finish_wrap( void *ctx, unsigned char *output )
161 {
162  md4_hmac_finish( (md4_context *) ctx, output );
163 }
164 
165 void md4_hmac_reset_wrap( void *ctx )
166 {
167  md4_hmac_reset( (md4_context *) ctx );
168 }
169 
170 void *md4_ctx_alloc( void )
171 {
172  return malloc( sizeof( md4_context ) );
173 }
174 
175 void md4_ctx_free( void *ctx )
176 {
177  free( ctx );
178 }
179 
180 const md_info_t md4_info = {
182  "MD4",
183  16,
184  md4_starts_wrap,
185  md4_update_wrap,
186  md4_finish_wrap,
187  md4,
188  md4_file_wrap,
189  md4_hmac_starts_wrap,
190  md4_hmac_update_wrap,
191  md4_hmac_finish_wrap,
192  md4_hmac_reset_wrap,
193  md4_hmac,
194  md4_ctx_alloc,
195  md4_ctx_free,
196 };
197 
198 #endif
199 
200 #if defined(POLARSSL_MD5_C)
201 
202 static void md5_starts_wrap( void *ctx )
203 {
204  md5_starts( (md5_context *) ctx );
205 }
206 
207 static void md5_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
208 {
209  md5_update( (md5_context *) ctx, input, ilen );
210 }
211 
212 static void md5_finish_wrap( void *ctx, unsigned char *output )
213 {
214  md5_finish( (md5_context *) ctx, output );
215 }
216 
217 int md5_file_wrap( const char *path, unsigned char *output )
218 {
219 #if defined(POLARSSL_FS_IO)
220  return md5_file( path, output );
221 #else
222  ((void) path);
223  ((void) output);
225 #endif
226 }
227 
228 static void md5_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
229 {
230  md5_hmac_starts( (md5_context *) ctx, key, keylen );
231 }
232 
233 static void md5_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
234 {
235  md5_hmac_update( (md5_context *) ctx, input, ilen );
236 }
237 
238 static void md5_hmac_finish_wrap( void *ctx, unsigned char *output )
239 {
240  md5_hmac_finish( (md5_context *) ctx, output );
241 }
242 
243 static void md5_hmac_reset_wrap( void *ctx )
244 {
245  md5_hmac_reset( (md5_context *) ctx );
246 }
247 
248 static void * md5_ctx_alloc( void )
249 {
250  return malloc( sizeof( md5_context ) );
251 }
252 
253 static void md5_ctx_free( void *ctx )
254 {
255  free( ctx );
256 }
257 
258 const md_info_t md5_info = {
260  "MD5",
261  16,
262  md5_starts_wrap,
263  md5_update_wrap,
264  md5_finish_wrap,
265  md5,
266  md5_file_wrap,
267  md5_hmac_starts_wrap,
268  md5_hmac_update_wrap,
269  md5_hmac_finish_wrap,
270  md5_hmac_reset_wrap,
271  md5_hmac,
272  md5_ctx_alloc,
273  md5_ctx_free,
274 };
275 
276 #endif
277 
278 #if defined(POLARSSL_SHA1_C)
279 
280 void sha1_starts_wrap( void *ctx )
281 {
282  sha1_starts( (sha1_context *) ctx );
283 }
284 
285 void sha1_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
286 {
287  sha1_update( (sha1_context *) ctx, input, ilen );
288 }
289 
290 void sha1_finish_wrap( void *ctx, unsigned char *output )
291 {
292  sha1_finish( (sha1_context *) ctx, output );
293 }
294 
295 int sha1_file_wrap( const char *path, unsigned char *output )
296 {
297 #if defined(POLARSSL_FS_IO)
298  return sha1_file( path, output );
299 #else
300  ((void) path);
301  ((void) output);
303 #endif
304 }
305 
306 void sha1_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
307 {
308  sha1_hmac_starts( (sha1_context *) ctx, key, keylen );
309 }
310 
311 void sha1_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
312 {
313  sha1_hmac_update( (sha1_context *) ctx, input, ilen );
314 }
315 
316 void sha1_hmac_finish_wrap( void *ctx, unsigned char *output )
317 {
318  sha1_hmac_finish( (sha1_context *) ctx, output );
319 }
320 
321 void sha1_hmac_reset_wrap( void *ctx )
322 {
323  sha1_hmac_reset( (sha1_context *) ctx );
324 }
325 
326 void * sha1_ctx_alloc( void )
327 {
328  return malloc( sizeof( sha1_context ) );
329 }
330 
331 void sha1_ctx_free( void *ctx )
332 {
333  free( ctx );
334 }
335 
336 const md_info_t sha1_info = {
338  "SHA1",
339  20,
340  sha1_starts_wrap,
341  sha1_update_wrap,
342  sha1_finish_wrap,
343  sha1,
344  sha1_file_wrap,
345  sha1_hmac_starts_wrap,
346  sha1_hmac_update_wrap,
347  sha1_hmac_finish_wrap,
348  sha1_hmac_reset_wrap,
349  sha1_hmac,
350  sha1_ctx_alloc,
351  sha1_ctx_free,
352 };
353 
354 #endif
355 
356 /*
357  * Wrappers for generic message digests
358  */
359 #if defined(POLARSSL_SHA2_C)
360 
361 void sha224_starts_wrap( void *ctx )
362 {
363  sha2_starts( (sha2_context *) ctx, 1 );
364 }
365 
366 void sha224_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
367 {
368  sha2_update( (sha2_context *) ctx, input, ilen );
369 }
370 
371 void sha224_finish_wrap( void *ctx, unsigned char *output )
372 {
373  sha2_finish( (sha2_context *) ctx, output );
374 }
375 
376 void sha224_wrap( const unsigned char *input, size_t ilen,
377  unsigned char *output )
378 {
379  sha2( input, ilen, output, 1 );
380 }
381 
382 int sha224_file_wrap( const char *path, unsigned char *output )
383 {
384 #if defined(POLARSSL_FS_IO)
385  return sha2_file( path, output, 1 );
386 #else
387  ((void) path);
388  ((void) output);
390 #endif
391 }
392 
393 void sha224_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
394 {
395  sha2_hmac_starts( (sha2_context *) ctx, key, keylen, 1 );
396 }
397 
398 void sha224_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
399 {
400  sha2_hmac_update( (sha2_context *) ctx, input, ilen );
401 }
402 
403 void sha224_hmac_finish_wrap( void *ctx, unsigned char *output )
404 {
405  sha2_hmac_finish( (sha2_context *) ctx, output );
406 }
407 
408 void sha224_hmac_reset_wrap( void *ctx )
409 {
410  sha2_hmac_reset( (sha2_context *) ctx );
411 }
412 
413 void sha224_hmac_wrap( const unsigned char *key, size_t keylen,
414  const unsigned char *input, size_t ilen,
415  unsigned char *output )
416 {
417  sha2_hmac( key, keylen, input, ilen, output, 1 );
418 }
419 
420 void * sha224_ctx_alloc( void )
421 {
422  return malloc( sizeof( sha2_context ) );
423 }
424 
425 void sha224_ctx_free( void *ctx )
426 {
427  free( ctx );
428 }
429 
430 const md_info_t sha224_info = {
432  "SHA224",
433  28,
434  sha224_starts_wrap,
435  sha224_update_wrap,
436  sha224_finish_wrap,
437  sha224_wrap,
438  sha224_file_wrap,
439  sha224_hmac_starts_wrap,
440  sha224_hmac_update_wrap,
441  sha224_hmac_finish_wrap,
442  sha224_hmac_reset_wrap,
443  sha224_hmac_wrap,
444  sha224_ctx_alloc,
445  sha224_ctx_free,
446 };
447 
448 void sha256_starts_wrap( void *ctx )
449 {
450  sha2_starts( (sha2_context *) ctx, 0 );
451 }
452 
453 void sha256_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
454 {
455  sha2_update( (sha2_context *) ctx, input, ilen );
456 }
457 
458 void sha256_finish_wrap( void *ctx, unsigned char *output )
459 {
460  sha2_finish( (sha2_context *) ctx, output );
461 }
462 
463 void sha256_wrap( const unsigned char *input, size_t ilen,
464  unsigned char *output )
465 {
466  sha2( input, ilen, output, 0 );
467 }
468 
469 int sha256_file_wrap( const char *path, unsigned char *output )
470 {
471 #if defined(POLARSSL_FS_IO)
472  return sha2_file( path, output, 0 );
473 #else
474  ((void) path);
475  ((void) output);
477 #endif
478 }
479 
480 void sha256_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
481 {
482  sha2_hmac_starts( (sha2_context *) ctx, key, keylen, 0 );
483 }
484 
485 void sha256_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
486 {
487  sha2_hmac_update( (sha2_context *) ctx, input, ilen );
488 }
489 
490 void sha256_hmac_finish_wrap( void *ctx, unsigned char *output )
491 {
492  sha2_hmac_finish( (sha2_context *) ctx, output );
493 }
494 
495 void sha256_hmac_reset_wrap( void *ctx )
496 {
497  sha2_hmac_reset( (sha2_context *) ctx );
498 }
499 
500 void sha256_hmac_wrap( const unsigned char *key, size_t keylen,
501  const unsigned char *input, size_t ilen,
502  unsigned char *output )
503 {
504  sha2_hmac( key, keylen, input, ilen, output, 0 );
505 }
506 
507 void * sha256_ctx_alloc( void )
508 {
509  return malloc( sizeof( sha2_context ) );
510 }
511 
512 void sha256_ctx_free( void *ctx )
513 {
514  free( ctx );
515 }
516 
517 const md_info_t sha256_info = {
519  "SHA256",
520  32,
521  sha256_starts_wrap,
522  sha256_update_wrap,
523  sha256_finish_wrap,
524  sha256_wrap,
525  sha256_file_wrap,
526  sha256_hmac_starts_wrap,
527  sha256_hmac_update_wrap,
528  sha256_hmac_finish_wrap,
529  sha256_hmac_reset_wrap,
530  sha256_hmac_wrap,
531  sha256_ctx_alloc,
532  sha256_ctx_free,
533 };
534 
535 #endif
536 
537 #if defined(POLARSSL_SHA4_C)
538 
539 void sha384_starts_wrap( void *ctx )
540 {
541  sha4_starts( (sha4_context *) ctx, 1 );
542 }
543 
544 void sha384_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
545 {
546  sha4_update( (sha4_context *) ctx, input, ilen );
547 }
548 
549 void sha384_finish_wrap( void *ctx, unsigned char *output )
550 {
551  sha4_finish( (sha4_context *) ctx, output );
552 }
553 
554 void sha384_wrap( const unsigned char *input, size_t ilen,
555  unsigned char *output )
556 {
557  sha4( input, ilen, output, 1 );
558 }
559 
560 int sha384_file_wrap( const char *path, unsigned char *output )
561 {
562 #if defined(POLARSSL_FS_IO)
563  return sha4_file( path, output, 1 );
564 #else
565  ((void) path);
566  ((void) output);
568 #endif
569 }
570 
571 void sha384_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
572 {
573  sha4_hmac_starts( (sha4_context *) ctx, key, keylen, 1 );
574 }
575 
576 void sha384_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
577 {
578  sha4_hmac_update( (sha4_context *) ctx, input, ilen );
579 }
580 
581 void sha384_hmac_finish_wrap( void *ctx, unsigned char *output )
582 {
583  sha4_hmac_finish( (sha4_context *) ctx, output );
584 }
585 
586 void sha384_hmac_reset_wrap( void *ctx )
587 {
588  sha4_hmac_reset( (sha4_context *) ctx );
589 }
590 
591 void sha384_hmac_wrap( const unsigned char *key, size_t keylen,
592  const unsigned char *input, size_t ilen,
593  unsigned char *output )
594 {
595  sha4_hmac( key, keylen, input, ilen, output, 1 );
596 }
597 
598 void * sha384_ctx_alloc( void )
599 {
600  return malloc( sizeof( sha4_context ) );
601 }
602 
603 void sha384_ctx_free( void *ctx )
604 {
605  free( ctx );
606 }
607 
608 const md_info_t sha384_info = {
610  "SHA384",
611  48,
612  sha384_starts_wrap,
613  sha384_update_wrap,
614  sha384_finish_wrap,
615  sha384_wrap,
616  sha384_file_wrap,
617  sha384_hmac_starts_wrap,
618  sha384_hmac_update_wrap,
619  sha384_hmac_finish_wrap,
620  sha384_hmac_reset_wrap,
621  sha384_hmac_wrap,
622  sha384_ctx_alloc,
623  sha384_ctx_free,
624 };
625 
626 void sha512_starts_wrap( void *ctx )
627 {
628  sha4_starts( (sha4_context *) ctx, 0 );
629 }
630 
631 void sha512_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
632 {
633  sha4_update( (sha4_context *) ctx, input, ilen );
634 }
635 
636 void sha512_finish_wrap( void *ctx, unsigned char *output )
637 {
638  sha4_finish( (sha4_context *) ctx, output );
639 }
640 
641 void sha512_wrap( const unsigned char *input, size_t ilen,
642  unsigned char *output )
643 {
644  sha4( input, ilen, output, 0 );
645 }
646 
647 int sha512_file_wrap( const char *path, unsigned char *output )
648 {
649 #if defined(POLARSSL_FS_IO)
650  return sha4_file( path, output, 0 );
651 #else
652  ((void) path);
653  ((void) output);
655 #endif
656 }
657 
658 void sha512_hmac_starts_wrap( void *ctx, const unsigned char *key, size_t keylen )
659 {
660  sha4_hmac_starts( (sha4_context *) ctx, key, keylen, 0 );
661 }
662 
663 void sha512_hmac_update_wrap( void *ctx, const unsigned char *input, size_t ilen )
664 {
665  sha4_hmac_update( (sha4_context *) ctx, input, ilen );
666 }
667 
668 void sha512_hmac_finish_wrap( void *ctx, unsigned char *output )
669 {
670  sha4_hmac_finish( (sha4_context *) ctx, output );
671 }
672 
673 void sha512_hmac_reset_wrap( void *ctx )
674 {
675  sha4_hmac_reset( (sha4_context *) ctx );
676 }
677 
678 void sha512_hmac_wrap( const unsigned char *key, size_t keylen,
679  const unsigned char *input, size_t ilen,
680  unsigned char *output )
681 {
682  sha4_hmac( key, keylen, input, ilen, output, 0 );
683 }
684 
685 void * sha512_ctx_alloc( void )
686 {
687  return malloc( sizeof( sha4_context ) );
688 }
689 
690 void sha512_ctx_free( void *ctx )
691 {
692  free( ctx );
693 }
694 
695 const md_info_t sha512_info = {
697  "SHA512",
698  64,
699  sha512_starts_wrap,
700  sha512_update_wrap,
701  sha512_finish_wrap,
702  sha512_wrap,
703  sha512_file_wrap,
704  sha512_hmac_starts_wrap,
705  sha512_hmac_update_wrap,
706  sha512_hmac_finish_wrap,
707  sha512_hmac_reset_wrap,
708  sha512_hmac_wrap,
709  sha512_ctx_alloc,
710  sha512_ctx_free,
711 };
712 
713 #endif
714 
715 #endif