source: trunk/src/sh_tiger0.c@ 551

Last change on this file since 551 was 541, checked in by katerina, 6 years ago

Fix for ticket #433 (coding standardisation).
File size: 50.6 KB
Line 
1#include "config_xor.h"
2
3#define USE_MD5
4#define USE_SHA1
5
6#include <stdio.h>
7#include <string.h>
8
9#include <sys/types.h>
10#ifdef HAVE_UNISTD_H
11#include <unistd.h>
12#endif
13#ifdef HAVE_MEMORY_H
14#include <memory.h>
15#endif
16
17#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
18#include <sys/mman.h>
19#endif
20
21#include "sh_tiger.h"
22
23#include "sh_unix.h"
24#include "sh_error.h"
25#include "sh_utils.h"
26#include "sh_pthread.h"
27#include "sh_string.h"
28
29#define PRIV_MAX 32768
30
31#if defined(TIGER_64_BIT)
32#if defined(HAVE_LONG_64)
33typedef unsigned long int word64;
34#elif defined(HAVE_LONG_LONG_64)
35typedef unsigned long long int word64;
36#else
37#error No 64 bit type found !
38#endif
39#endif
40
41#if defined(HAVE_INT_32)
42typedef unsigned int sh_word32;
43#define MYFORMAT (_("%08X%08X%08X%08X%08X%08X"))
44#define GPGFORMAT (_("%08X %08X %08X %08X %08X %08X"))
45#elif defined(HAVE_LONG_32)
46typedef unsigned long sh_word32;
47#define MYFORMAT (_("%08lX%08lX%08lX%08lX%08lX%08lX"))
48#define GPGFORMAT (_("%08lX %08lX %08lX %08lX %08lX %08lX"))
49#elif defined(HAVE_SHORT_32)
50typedef unsigned short sh_word32;
51#define MYFORMAT (_("%08X%08X%08X%08X%08X%08X"))
52#define GPGFORMAT (_("%08X %08X %08X %08X %08X %08X"))
53#else
54#error No 32 bit type found !
55#endif
56
57#if defined(__GNUC__) && (__GNUC__ >= 3)
58#undef SH_GNUC_ALIGN8
59#define SH_GNUC_ALIGN8 __attribute__((aligned(8)))
60#else
61#undef SH_GNUC_ALIGN8
62#define SH_GNUC_ALIGN8
63#endif
64
65
66typedef unsigned char sh_byte;
67
68#define SH_KEY_NULL _("000000000000000000000000000000000000000000000000")
69
70#undef FIL__
71#define FIL__ _("sh_tiger0.c")
72
73#if defined(TIGER_64_BIT)
74
75void tiger_t(const word64 *str, word64 length, word64 * res);
76void tiger(const word64 *str, word64 length, word64 * res);
77
78#ifdef TIGER_DBG
79static void tiger_dbg(word64 res[3], int step,
80 unsigned long nblocks, unsigned long ncount)
81{
82 return;
83}
84#endif
85#else
86void tiger(const sh_word32 *str, sh_word32 length, sh_word32 * res);
87void tiger_t(const sh_word32 *str, sh_word32 length, sh_word32 * res);
88
89#ifdef TIGER_DBG
90static
91void tiger_dbg(sh_word32 res[6], int step,
92 unsigned long nblocks, unsigned long ncount)
93{
94 fprintf(stderr,
95 _("ST %d BLK %2ld CT %2ld %08lX %08lX %08lX %08lX %08lX %08lX\n"),
96 step,
97 nblocks,
98 ncount,
99 (sh_word32)(res[1]),
100 (sh_word32)(res[0]),
101 (sh_word32)(res[3]),
102 (sh_word32)(res[2]),
103 (sh_word32)(res[5]),
104 (sh_word32)(res[4]) );
105}
106#endif
107#endif
108
109/* this is the wrapper function -- not part of the tiger reference
110 * implementation
111 */
112
113/* static sh_byte buffer[PRIV_MAX + 72]; */
114
115#if defined(TIGER_64_BIT)
116static
117word64 * sh_tiger_hash_val (const char * filename, TigerType what,
118 UINT64 * Length, int timeout, word64 * res)
119#else
120static
121sh_word32 * sh_tiger_hash_val (const char * filename, TigerType what,
122 UINT64 * Length, int timeout, sh_word32 * res)
123#endif
124{
125 SL_TICKET fd;
126 sh_string * content = NULL;
127 int i, j, tt;
128 int count = 0;
129 int blk;
130 char * tmp;
131 sh_byte * bptr;
132 sh_byte SH_GNUC_ALIGN8 bbuf[64];
133 UINT64 bcount = 0;
134
135 sh_byte * buffer = SH_ALLOC(PRIV_MAX + 72);
136
137 unsigned long pages_read;
138 uid_t euid;
139
140 unsigned long ncount = 0, nblocks = 0;
141 unsigned long t, msb, lsb;
142
143#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
144 /*@-nestedextern@*/
145 extern long IO_Limit;
146 /*@+nestedextern@*/
147#endif
148
149#if defined(TIGER_64_BIT)
150#define TIGER_CAST (const word64*)
151 /* word64 res[3]; */
152 res[0]= (word64) 0x0123456789ABCDEFLL;
153 res[1]= (word64) 0xFEDCBA9876543210LL;
154 res[2]= (word64) 0xF096A5B4C3B2E187LL;
155#else
156#define TIGER_CAST (const sh_word32*)
157 /* sh_word32 res[6]; */
158 res[0]= (sh_word32) 0x89ABCDEF;
159 res[1]= (sh_word32) 0x01234567;
160 res[2]= (sh_word32) 0x76543210;
161 res[3]= (sh_word32) 0xFEDCBA98;
162 res[4]= (sh_word32) 0xC3B2E187;
163 res[5]= (sh_word32) 0xF096A5B4;
164#endif
165
166 SL_ENTER(_("sh_tiger_hash_val"));
167
168 if (what >= TIGER_FILE)
169 {
170 if (what > TIGER_FILE)
171 {
172 fd = what;
173 content = sl_get_content(fd);
174 TPT((0,FIL__, __LINE__, _("msg=<TIGER_FD>, fd=<%ld>\n"), fd));
175 }
176 else
177 {
178 TPT((0,FIL__, __LINE__, _("msg=<TIGER_FILE>, path=<%s>\n"),
179 (filename == NULL ? _("(null)") : filename) ));
180 fd = sl_open_read (FIL__, __LINE__, filename, SL_YESPRIV);
181 }
182
183 if (SL_ISERROR (fd))
184 {
185 TPT((0, FIL__, __LINE__, _("msg=<SL_ISERROR (%ld)>\n"), fd));
186 tmp = sh_util_safe_name (filename);
187 (void) sl_get_euid(&euid);
188 sh_error_handle (ShDFLevel[SH_ERR_T_FILE], FIL__, __LINE__, (int)fd,
189 MSG_E_ACCESS, (long) euid, tmp);
190 SH_FREE(tmp);
191 SH_FREE(buffer);
192 *Length = 0;
193 SL_RETURN( NULL, _("sh_tiger_hash_val"));
194 }
195
196#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
197 if (skey->mlock_failed == S_FALSE)
198 {
199 if ( (-1) == sh_unix_mlock(FIL__, __LINE__,
200 (char *)buffer,
201 (PRIV_MAX)*sizeof(sh_byte)))
202 {
203 SH_MUTEX_LOCK_UNSAFE(mutex_skey);
204 skey->mlock_failed = S_TRUE;
205 SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
206 }
207 }
208#else
209 if (skey->mlock_failed == S_FALSE)
210 {
211 SH_MUTEX_LOCK_UNSAFE(mutex_skey);
212 skey->mlock_failed = S_TRUE;
213 SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
214 }
215#endif
216
217#ifdef TIGER_DBG
218 tiger_dbg (res, 0, nblocks, ncount);
219#endif
220
221 pages_read = 0;
222
223 while (1)
224 {
225 if (timeout > 0)
226 count = sl_read_timeout (fd, buffer, PRIV_MAX, timeout, S_TRUE);
227 else
228 count = sl_read (fd, buffer, PRIV_MAX);
229
230 ++pages_read;
231
232 if (SL_ISERROR (count))
233 {
234 int error = errno;
235
236 if (sig_termfast == 1) {
237 sh_unix_munlock((char *)buffer, (PRIV_MAX)*sizeof(sh_byte));
238 SH_FREE(buffer);
239 *Length = 0;
240 SL_RETURN( NULL, _("sh_tiger_hash_val"));
241 }
242 TPT((0, FIL__ , __LINE__ , _("msg=<SL_ISERROR (%ld)>\n"), count));
243 tmp = sh_util_safe_name (filename);
244 if (count == SL_TIMEOUT)
245 {
246 if (timeout != 7) {
247 sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, count,
248 MSG_E_TIMEOUT, timeout, tmp);
249 }
250 }
251 else
252 {
253 char errbuf[SH_ERRBUF_SIZE];
254 char errbuf2[SH_ERRBUF_SIZE];
255 sl_strlcpy(errbuf, sl_error_string(count), sizeof(errbuf));
256 sh_error_message(error, errbuf2, sizeof(errbuf2));
257 sh_error_handle (ShDFLevel[SH_ERR_T_FILE], FIL__, __LINE__,
258 count, MSG_E_READ, errbuf, errbuf2, tmp);
259 }
260 SH_FREE(tmp);
261 memset (bbuf, 0, 64);
262 memset (buffer, 0, PRIV_MAX);
263
264 sh_unix_munlock((char *)buffer, (PRIV_MAX)*sizeof(sh_byte));
265 SH_FREE(buffer);
266 *Length = 0;
267 SL_RETURN( NULL, _("sh_tiger_hash_val"));
268 }
269
270 if (content)
271 sh_string_cat_lchar(content, (char*)buffer, count);
272
273 bcount += count;
274
275 if (*Length != TIGER_NOLIM)
276 {
277 if (bcount > *Length)
278 {
279 count = count - (bcount - (*Length));
280 bcount = *Length;
281 count = (count < 0) ? 0 : count;
282 }
283 }
284
285 blk = (count / 64); /* number of 64-byte words */
286
287 /* nblocks += blk; number of 64-byte words
288 * count cannot be negative here, see 'if (SL_ISERROR (count))'
289 */
290 tt = blk*64;
291
292 ncount = (unsigned long) (count - tt);
293
294 nblocks += blk;
295 /* MAY_LOCK */
296 sh.statistics.bytes_hashed += tt;
297
298 tt = 0;
299 for (i = 0; i < blk; ++i)
300 {
301 bptr = &buffer[tt]; tt += 64;
302
303 tiger_t(TIGER_CAST bptr, 64, res);
304
305#ifdef TIGER_DBG
306 tiger_dbg (res, 3, nblocks, ncount);
307#endif
308 }
309
310 if (blk < (PRIV_MAX / 64)) /* this must be (PRIV_MAX / 64) */
311 break;
312
313#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
314 if (sig_termfast == 1)
315 {
316 memset (bbuf, 0, 64);
317 memset (buffer, 0, PRIV_MAX);
318 sh_unix_munlock((char *)buffer, (PRIV_MAX)*sizeof(sh_byte));
319 SH_FREE(buffer);
320 *Length = 0;
321 SL_RETURN( NULL, _("sh_tiger_hash_val"));
322 }
323 if ((IO_Limit) > 0 && (pages_read == 32)) /* check for I/O limit */
324 {
325 sh_unix_io_pause ();
326 pages_read = 0;
327 }
328#endif
329 }
330
331 TPT((0, FIL__, __LINE__ , _("msg=<Last block.>\n")));
332
333 /* copy incomplete block
334 */
335 j = 0;
336 for (i = 0; i < 64; i += 4)
337 {
338 bbuf[i] = (sh_byte) '\0';
339 bbuf[i+1] = (sh_byte) '\0';
340 bbuf[i+2] = (sh_byte) '\0';
341 bbuf[i+3] = (sh_byte) '\0';
342 }
343 for (i = (count/64) * 64; i < count; ++i)
344 /*@-usedef@*/bbuf[j++] = buffer[i];/*@+usedef@*/
345
346#ifdef TIGER_DBG
347 tiger_dbg (res, 5, nblocks, ncount);
348#endif
349
350 msb = 0;
351 t = nblocks;
352 if( (lsb = t << 6) < t )
353 msb++;
354 msb += t >> 26;
355 t = lsb;
356 if( (lsb = t + ncount) < t )
357 msb++;
358 t = lsb;
359 if( (lsb = t << 3) < t )
360 msb++;
361 msb += t >> 29;
362
363 if( j < 56 )
364 {
365 bbuf[j++] = (sh_byte) 0x01; ++ncount;
366 while( j < 56 )
367 { bbuf[j++] = (sh_byte) 0; ++ncount; }
368 }
369 else
370 {
371 bbuf[j++] = (sh_byte) 0x01;
372 while( j < 64 )
373 bbuf[j++] = (sh_byte) 0;
374 tiger_t(TIGER_CAST bbuf, 64, res);
375 /* MAY_LOCK */
376 sh.statistics.bytes_hashed += 64;
377 ++nblocks;
378#ifdef TIGER_DBG
379 ncount = 0;
380#endif
381 memset(bbuf, 0, 56 );
382 }
383
384#ifdef TIGER_DBG
385 tiger_dbg (res, 6, nblocks, ncount);
386#endif
387
388 bbuf[56] = (sh_byte) (lsb );
389 bbuf[57] = (sh_byte) (lsb >> 8);
390 bbuf[58] = (sh_byte) (lsb >> 16);
391 bbuf[59] = (sh_byte) (lsb >> 24);
392 bbuf[60] = (sh_byte) (msb );
393 bbuf[61] = (sh_byte) (msb >> 8);
394 bbuf[62] = (sh_byte) (msb >> 16);
395 bbuf[63] = (sh_byte) (msb >> 24);
396
397 tiger_t(TIGER_CAST bbuf, 64, res);
398 sh.statistics.bytes_hashed += 64;
399
400#ifdef TIGER_DBG
401 tiger_dbg (res, 7, nblocks, ncount);
402#endif
403
404 memset (bbuf, 0, sizeof(bbuf));
405 memset (buffer, 0, sizeof(buffer));
406
407 if (what == TIGER_FILE)
408 (void) sl_close (fd);
409 sh_unix_munlock((char *)buffer, (PRIV_MAX)*sizeof(sh_byte));
410 SH_FREE(buffer);
411 *Length = bcount;
412 SL_RETURN( res, _("sh_tiger_hash_val"));
413 }
414
415 if (what == TIGER_DATA && filename != NULL)
416 {
417 tiger(TIGER_CAST filename, (sh_word32) *Length, res);
418 sh_unix_munlock((char *)buffer, (PRIV_MAX)*sizeof(sh_byte));
419 SH_FREE(buffer);
420 SL_RETURN(res, _("sh_tiger_hash_val"));
421 }
422 sh_unix_munlock((char *)buffer, (PRIV_MAX)*sizeof(sh_byte));
423 SH_FREE(buffer);
424 *Length = 0;
425 SL_RETURN( NULL, _("sh_tiger_hash_val"));
426}
427
428/* Thu Oct 18 18:53:33 CEST 2001
429 */
430
431#ifdef USE_MD5
432/*@-type@*/
433/* md5.c - Functions to compute MD5 message digest of files or memory blocks
434 * according to the definition of MD5 in RFC 1321 from April 1992.
435 * Copyright (C) 1995, 1996 Free Software Foundation, Inc.
436 *
437 * NOTE: The canonical source of this file is maintained with the GNU C
438 * Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu.
439 *
440 * This program is free software; you can redistribute it and/or modify it
441 * under the terms of the GNU General Public License as published by the
442 * Free Software Foundation; either version 2, or (at your option) any
443 * later version.
444 *
445 * This program is distributed in the hope that it will be useful,
446 * but WITHOUT ANY WARRANTY; without even the implied warranty of
447 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
448 * GNU General Public License for more details.
449 *
450 * You should have received a copy of the GNU General Public License
451 * along with this program; if not, write to the Free Software Foundation,
452 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
453 */
454
455/* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995. */
456
457/* Hacked to work with samhain by R. Wichmann */
458
459typedef UINT32 md5_uint32;
460
461
462/* Structure to save state of computation between the single steps. */
463typedef struct md5_ctx
464{
465 md5_uint32 A;
466 md5_uint32 B;
467 md5_uint32 C;
468 md5_uint32 D;
469
470 md5_uint32 total[2];
471 md5_uint32 buflen;
472 char buffer[128];
473} md5Param;
474
475/*
476 * The following three functions are build up the low level used in
477 * the functions `md5_stream' and `md5_buffer'.
478 */
479
480/* Initialize structure containing state of computation.
481 (RFC 1321, 3.3: Step 3) */
482static void md5_init_ctx (struct md5_ctx *ctx);
483
484/* Starting with the result of former calls of this function (or the
485 initialization function update the context for the next LEN bytes
486 starting at BUFFER.
487 It is necessary that LEN is a multiple of 64!!! */
488static void md5_process_block (const void *buffer, size_t len,
489 struct md5_ctx *ctx);
490
491/* Starting with the result of former calls of this function (or the
492 initialization function update the context for the next LEN bytes
493 starting at BUFFER.
494 It is NOT required that LEN is a multiple of 64. */
495static void md5_process_bytes (const void *buffer, size_t len,
496 struct md5_ctx *ctx);
497
498/* Process the remaining bytes in the buffer and put result from CTX
499 in first 16 bytes following RESBUF. The result is always in little
500 endian byte order, so that a byte-wise output yields to the wanted
501 ASCII representation of the message digest.
502
503 IMPORTANT: On some systems it is required that RESBUF is correctly
504 aligned for a 32 bits value. */
505static void *md5_finish_ctx (struct md5_ctx *ctx, void *resbuf);
506
507
508/* Put result from CTX in first 16 bytes following RESBUF. The result is
509 always in little endian byte order, so that a byte-wise output yields
510 to the wanted ASCII representation of the message digest.
511
512 IMPORTANT: On some systems it is required that RESBUF is correctly
513 aligned for a 32 bits value. */
514static void *md5_read_ctx (const struct md5_ctx *ctx, void *resbuf);
515
516#if WORDS_BIGENDIAN
517static md5_uint32 swapu32(md5_uint32 n)
518{
519 return ( ((n & 0xffU) << 24) |
520 ((n & 0xff00U) << 8) |
521 ((n & 0xff0000U) >> 8) |
522 ((n & 0xff000000U) >> 24) );
523}
524#define SWAP(n) swapu32(n)
525#else
526#define SWAP(n) (n)
527#endif
528
529/* This array contains the bytes used to pad the buffer to the next
530 64-byte boundary. (RFC 1321, 3.1: Step 1) */
531static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
532
533/* Initialize structure containing state of computation.
534 (RFC 1321, 3.3: Step 3) */
535static void md5_init_ctx(struct md5_ctx *ctx)
536{
537 ctx->A = 0x67452301;
538 ctx->B = 0xefcdab89;
539 ctx->C = 0x98badcfe;
540 ctx->D = 0x10325476;
541
542 ctx->total[0] = ctx->total[1] = 0;
543 ctx->buflen = 0;
544}
545
546/* Put result from CTX in first 16 bytes following RESBUF. The result
547 must be in little endian byte order.
548
549 IMPORTANT: On some systems it is required that RESBUF is correctly
550 aligned for a 32 bits value. */
551static void *md5_read_ctx(const struct md5_ctx *ctx, void *resbuf)
552{
553 ((md5_uint32 *) resbuf)[0] = SWAP(ctx->A);
554 ((md5_uint32 *) resbuf)[1] = SWAP(ctx->B);
555 ((md5_uint32 *) resbuf)[2] = SWAP(ctx->C);
556 ((md5_uint32 *) resbuf)[3] = SWAP(ctx->D);
557
558 return resbuf;
559}
560
561/* Process the remaining bytes in the internal buffer and the usual
562 prolog according to the standard and write the result to RESBUF.
563
564 IMPORTANT: On some systems it is required that RESBUF is correctly
565 aligned for a 32 bits value. */
566static void *md5_finish_ctx(struct md5_ctx *ctx, void *resbuf)
567{
568 /* Take yet unprocessed bytes into account. */
569 md5_uint32 bytes = ctx->buflen;
570 size_t pad;
571 md5_uint32 temp;
572
573 /* Now count remaining bytes. */
574 ctx->total[0] += bytes;
575 if (ctx->total[0] < bytes)
576 ++ctx->total[1];
577
578 pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
579 memcpy(&ctx->buffer[bytes], fillbuf, pad);
580
581 /* Put the 64-bit file length in *bits* at the end of the buffer. */
582 temp = SWAP(ctx->total[0] << 3);
583 memcpy(&(ctx->buffer[bytes + pad]), &temp, sizeof(temp));
584 temp = SWAP((ctx->total[1] << 3) | (ctx->total[0] >> 29));
585 memcpy(&(ctx->buffer[bytes + pad + 4]), &temp, sizeof(temp));
586
587 /* Process last bytes. */
588 md5_process_block(ctx->buffer, bytes + pad + 8, ctx);
589
590 return md5_read_ctx(ctx, resbuf);
591}
592
593/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
594 result is always in little endian byte order, so that a byte-wise
595 output yields to the wanted ASCII representation of the message
596 digest. */
597void *md5_buffer(const char *buffer, size_t len, void *resblock)
598{
599 struct md5_ctx ctx;
600
601 /* Initialize the computation context. */
602 md5_init_ctx(&ctx);
603
604 /* Process whole buffer but last len % 64 bytes. */
605 md5_process_bytes(buffer, len, &ctx);
606
607 /* Put result in desired memory area. */
608 return md5_finish_ctx(&ctx, resblock);
609}
610
611static void md5_process_bytes(const void *buffer, size_t len, struct md5_ctx *ctx)
612{
613 /* When we already have some bits in our internal buffer concatenate
614 both inputs first. */
615 if (ctx->buflen != 0) {
616 size_t left_over = ctx->buflen;
617 size_t add = 128 - left_over > len ? len : 128 - left_over;
618
619 memcpy(&ctx->buffer[left_over], buffer, add);
620 ctx->buflen += add;
621
622 if (left_over + add > 64) {
623 md5_process_block(ctx->buffer, (left_over + add) & ~63, ctx);
624 /* The regions in the following copy operation cannot overlap. */
625 memcpy(ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
626 (left_over + add) & 63);
627 ctx->buflen = (left_over + add) & 63;
628 }
629
630 buffer = (const char *) buffer + add;
631 len -= add;
632 }
633
634 /* Process available complete blocks. */
635 if (len > 64) {
636 md5_process_block(buffer, len & ~63, ctx);
637 buffer = (const char *) buffer + (len & ~63);
638 len &= 63;
639 }
640
641 /* Move remaining bytes in internal buffer. */
642 if (len > 0) {
643 memcpy(ctx->buffer, buffer, len);
644 ctx->buflen = len;
645 }
646}
647
648/* These are the four functions used in the four steps of the MD5 algorithm
649 and defined in the RFC 1321. The first function is a little bit optimized
650 (as found in Colin Plumbs public domain implementation). */
651/* #define FF(b, c, d) ((b & c) | (~b & d)) */
652#define FF(b, c, d) (d ^ (b & (c ^ d)))
653#define FG(b, c, d) FF (d, b, c)
654#define FH(b, c, d) (b ^ c ^ d)
655#define FI(b, c, d) (c ^ (b | ~d))
656
657/* Process LEN bytes of BUFFER, accumulating context into CTX.
658 It is assumed that LEN % 64 == 0. */
659static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ctx)
660{
661 md5_uint32 correct_words[16];
662 const md5_uint32 *words = buffer;
663 size_t nwords = len / sizeof(md5_uint32);
664 const md5_uint32 *endp = words + nwords;
665 md5_uint32 A = ctx->A;
666 md5_uint32 B = ctx->B;
667 md5_uint32 C = ctx->C;
668 md5_uint32 D = ctx->D;
669
670 /* First increment the byte count. RFC 1321 specifies the possible
671 length of the file up to 2^64 bits. Here we only compute the
672 number of bytes. Do a double word increment. */
673 ctx->total[0] += len;
674 if (ctx->total[0] < len)
675 ++ctx->total[1];
676
677 /* Process all bytes in the buffer with 64 bytes in each round of
678 the loop. */
679 while (words < endp) {
680 md5_uint32 *cwp = correct_words;
681 md5_uint32 A_save = A;
682 md5_uint32 B_save = B;
683 md5_uint32 C_save = C;
684 md5_uint32 D_save = D;
685
686 /* First round: using the given function, the context and a constant
687 the next context is computed. Because the algorithms processing
688 unit is a 32-bit word and it is determined to work on words in
689 little endian byte order we perhaps have to change the byte order
690 before the computation. To reduce the work for the next steps
691 we store the swapped words in the array CORRECT_WORDS. */
692
693#define OP(a, b, c, d, s, T) \
694 do \
695 { \
696 a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T; \
697 ++words; \
698 CYCLIC (a, s); \
699 a += b; \
700 } \
701 while (0)
702
703 /* It is unfortunate that C does not provide an operator for
704 cyclic rotation. Hope the C compiler is smart enough. */
705#define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
706
707 /* Before we start, one word to the strange constants.
708 They are defined in RFC 1321 as
709
710 T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
711 */
712
713 /* Round 1. */
714 OP(A, B, C, D, 7, 0xd76aa478);
715 OP(D, A, B, C, 12, 0xe8c7b756);
716 OP(C, D, A, B, 17, 0x242070db);
717 OP(B, C, D, A, 22, 0xc1bdceee);
718 OP(A, B, C, D, 7, 0xf57c0faf);
719 OP(D, A, B, C, 12, 0x4787c62a);
720 OP(C, D, A, B, 17, 0xa8304613);
721 OP(B, C, D, A, 22, 0xfd469501);
722 OP(A, B, C, D, 7, 0x698098d8);
723 OP(D, A, B, C, 12, 0x8b44f7af);
724 OP(C, D, A, B, 17, 0xffff5bb1);
725 OP(B, C, D, A, 22, 0x895cd7be);
726 OP(A, B, C, D, 7, 0x6b901122);
727 OP(D, A, B, C, 12, 0xfd987193);
728 OP(C, D, A, B, 17, 0xa679438e);
729 OP(B, C, D, A, 22, 0x49b40821);
730 /* For the second to fourth round we have the possibly swapped words
731 in CORRECT_WORDS. Redefine the macro to take an additional first
732 argument specifying the function to use. */
733#undef OP
734#define OP(f, a, b, c, d, k, s, T) \
735 do \
736 { \
737 a += f (b, c, d) + correct_words[k] + T; \
738 CYCLIC (a, s); \
739 a += b; \
740 } \
741 while (0)
742
743 /* Round 2. */
744 OP(FG, A, B, C, D, 1, 5, 0xf61e2562);
745 OP(FG, D, A, B, C, 6, 9, 0xc040b340);
746 OP(FG, C, D, A, B, 11, 14, 0x265e5a51);
747 OP(FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
748 OP(FG, A, B, C, D, 5, 5, 0xd62f105d);
749 OP(FG, D, A, B, C, 10, 9, 0x02441453);
750 OP(FG, C, D, A, B, 15, 14, 0xd8a1e681);
751 OP(FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
752 OP(FG, A, B, C, D, 9, 5, 0x21e1cde6);
753 OP(FG, D, A, B, C, 14, 9, 0xc33707d6);
754 OP(FG, C, D, A, B, 3, 14, 0xf4d50d87);
755 OP(FG, B, C, D, A, 8, 20, 0x455a14ed);
756 OP(FG, A, B, C, D, 13, 5, 0xa9e3e905);
757 OP(FG, D, A, B, C, 2, 9, 0xfcefa3f8);
758 OP(FG, C, D, A, B, 7, 14, 0x676f02d9);
759 OP(FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
760
761 /* Round 3. */
762 OP(FH, A, B, C, D, 5, 4, 0xfffa3942);
763 OP(FH, D, A, B, C, 8, 11, 0x8771f681);
764 OP(FH, C, D, A, B, 11, 16, 0x6d9d6122);
765 OP(FH, B, C, D, A, 14, 23, 0xfde5380c);
766 OP(FH, A, B, C, D, 1, 4, 0xa4beea44);
767 OP(FH, D, A, B, C, 4, 11, 0x4bdecfa9);
768 OP(FH, C, D, A, B, 7, 16, 0xf6bb4b60);
769 OP(FH, B, C, D, A, 10, 23, 0xbebfbc70);
770 OP(FH, A, B, C, D, 13, 4, 0x289b7ec6);
771 OP(FH, D, A, B, C, 0, 11, 0xeaa127fa);
772 OP(FH, C, D, A, B, 3, 16, 0xd4ef3085);
773 OP(FH, B, C, D, A, 6, 23, 0x04881d05);
774 OP(FH, A, B, C, D, 9, 4, 0xd9d4d039);
775 OP(FH, D, A, B, C, 12, 11, 0xe6db99e5);
776 OP(FH, C, D, A, B, 15, 16, 0x1fa27cf8);
777 OP(FH, B, C, D, A, 2, 23, 0xc4ac5665);
778
779 /* Round 4. */
780 OP(FI, A, B, C, D, 0, 6, 0xf4292244);
781 OP(FI, D, A, B, C, 7, 10, 0x432aff97);
782 OP(FI, C, D, A, B, 14, 15, 0xab9423a7);
783 OP(FI, B, C, D, A, 5, 21, 0xfc93a039);
784 OP(FI, A, B, C, D, 12, 6, 0x655b59c3);
785 OP(FI, D, A, B, C, 3, 10, 0x8f0ccc92);
786 OP(FI, C, D, A, B, 10, 15, 0xffeff47d);
787 OP(FI, B, C, D, A, 1, 21, 0x85845dd1);
788 OP(FI, A, B, C, D, 8, 6, 0x6fa87e4f);
789 OP(FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
790 OP(FI, C, D, A, B, 6, 15, 0xa3014314);
791 OP(FI, B, C, D, A, 13, 21, 0x4e0811a1);
792 OP(FI, A, B, C, D, 4, 6, 0xf7537e82);
793 OP(FI, D, A, B, C, 11, 10, 0xbd3af235);
794 OP(FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
795 OP(FI, B, C, D, A, 9, 21, 0xeb86d391);
796
797 /* Add the starting values of the context. */
798 A += A_save;
799 B += B_save;
800 C += C_save;
801 D += D_save;
802 }
803
804 /* Put checksum in context given as argument. */
805 ctx->A = A;
806 ctx->B = B;
807 ctx->C = C;
808 ctx->D = D;
809}
810
811
812/*----------------------------------------------------------------------------
813 *--------end of md5.c
814 *----------------------------------------------------------------------------*/
815
816
817int md5Reset(register md5Param* p)
818{
819 unsigned int i;
820
821 md5_init_ctx(p);
822
823 for (i = 0; i < 16; i += 8)
824 {
825 p->buffer[i] = 0x00;
826 p->buffer[i+1] = 0x00;
827 p->buffer[i+2] = 0x00;
828 p->buffer[i+3] = 0x00;
829 p->buffer[i+4] = 0x00;
830 p->buffer[i+5] = 0x00;
831 p->buffer[i+6] = 0x00;
832 p->buffer[i+7] = 0x00;
833 }
834
835 return 0;
836}
837
838int md5Update(md5Param* p, const sh_byte* data, int size)
839{
840 md5_process_bytes(data, size, p);
841 return 0;
842}
843
844static void md5Finish(md5Param* p, void *resblock)
845{
846 (void) md5_finish_ctx(p, resblock);
847}
848
849int md5Digest(md5Param* p, md5_uint32* data)
850{
851 md5Finish(p, data);
852 (void) md5Reset(p);
853 return 0;
854}
855/*@+type@*/
856
857
858/* Compute MD5 message digest for bytes read from STREAM. The
859 resulting message digest number will be written into the 16 bytes
860 beginning at RESBLOCK. */
861static int md5_stream(char * filename, void *resblock,
862 UINT64 * Length, int timeout, SL_TICKET fd)
863{
864 /* Important: BLOCKSIZE must be a multiple of 64. */
865 static const int BLOCKSIZE = 8192;
866 struct md5_ctx ctx;
867 char * buffer = SH_ALLOC(8264); /* BLOCKSIZE + 72 AIX compiler chokes */
868 size_t sum;
869
870 char * tmp;
871 uid_t euid;
872 UINT64 bcount = 0;
873 sh_string * content;
874
875 unsigned long pages_read;
876#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
877 /*@-nestedextern@*/
878 extern long IO_Limit;
879 /*@+nestedextern@*/
880#endif
881
882 /* Initialize the computation context. */
883 (void) md5Reset (&ctx);
884
885 if (SL_ISERROR (fd))
886 {
887 TPT((0, FIL__, __LINE__, _("msg=<SL_ISERROR (%ld)>\n"), fd));
888 tmp = sh_util_safe_name (filename);
889 (void) sl_get_euid(&euid);
890 sh_error_handle (ShDFLevel[SH_ERR_T_FILE], FIL__, __LINE__, fd,
891 MSG_E_ACCESS, (long) euid, tmp);
892 SH_FREE(tmp);
893 *Length = 0;
894 SH_FREE(buffer);
895 return -1;
896 }
897
898 pages_read = 0;
899
900 content = sl_get_content(fd);
901
902 /* Iterate over full file contents. */
903 while (1) {
904 /* We read the file in blocks of BLOCKSIZE bytes. One call of the
905 computation function processes the whole buffer so that with the
906 next round of the loop another block can be read. */
907 off_t n;
908 sum = 0;
909
910 /* Read block. Take care for partial reads. */
911 do {
912
913 n = (off_t) sl_read_timeout (fd, buffer + sum,
914 (size_t) BLOCKSIZE - sum, timeout, S_FALSE);
915
916 if (SL_ISERROR (n))
917 {
918 int error = errno;
919
920 if (sig_termfast == 1)
921 {
922 SH_FREE(buffer);
923 return -1;
924 }
925 TPT((0, FIL__ , __LINE__ , _("msg=<SL_ISERROR (%ld)>\n"), n));
926 tmp = sh_util_safe_name (filename);
927 if (n == SL_TIMEOUT)
928 {
929 if (timeout != 7) {
930 sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, n, MSG_E_TIMEOUT,
931 timeout, tmp);
932 }
933 }
934 else
935 {
936 char errbuf[SH_ERRBUF_SIZE];
937 char errbuf2[SH_ERRBUF_SIZE];
938 sl_strlcpy(errbuf, sl_error_string(n), sizeof(errbuf));
939 sh_error_message(error, errbuf2, sizeof(errbuf2));
940 sh_error_handle (ShDFLevel[SH_ERR_T_FILE], FIL__, __LINE__, n,
941 MSG_E_READ, errbuf, errbuf2, tmp);
942 }
943 SH_FREE(tmp);
944 *Length = 0;
945 SH_FREE(buffer);
946 return -1;
947 }
948
949 if (content)
950 sh_string_cat_lchar(content, buffer, n);
951
952 bcount += n;
953
954 if (*Length != TIGER_NOLIM)
955 {
956 if (bcount > *Length)
957 {
958 n = n - (bcount - (*Length));
959 bcount = *Length;
960 n = (n < 0) ? 0 : n;
961 }
962 }
963
964 sum += n;
965 }
966 while (sum < (size_t) BLOCKSIZE
967 && n != 0);
968
969 ++pages_read;
970
971 /* If end of file is reached, end the loop. */
972 if (n == 0)
973 break;
974
975 /* Process buffer with BLOCKSIZE bytes. Note that
976 BLOCKSIZE % 64 == 0
977 */
978 md5_process_block(buffer, BLOCKSIZE, &ctx);
979 sh.statistics.bytes_hashed += BLOCKSIZE;
980
981#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
982 if ((IO_Limit) > 0 && (pages_read == 32)) /* check for I/O limit */
983 {
984 sh_unix_io_pause ();
985 pages_read = 0;
986 }
987 if (sig_termfast == 1)
988 {
989 *Length = 0;
990 SH_FREE(buffer);
991 return -1;
992 }
993#endif
994 }
995
996 /* Add the last bytes if necessary. */
997 if (sum > 0)
998 {
999 md5_process_bytes(buffer, sum, &ctx);
1000 sh.statistics.bytes_hashed += BLOCKSIZE;
1001 }
1002
1003 /* Construct result in desired memory. */
1004 (void) md5Digest(&ctx, resblock);
1005
1006 *Length = bcount;
1007 SH_FREE(buffer);
1008 return 0;
1009}
1010
1011static
1012char * sh_tiger_md5_hash (char * filename, TigerType what,
1013 UINT64 * Length, int timeout, char * out, size_t len)
1014{
1015 int cnt;
1016 char outbuf[KEY_LEN+1];
1017 unsigned char md5buffer[16];
1018
1019 (void) md5_stream (filename, md5buffer, Length, timeout, what);
1020
1021 /*@-bufferoverflowhigh -usedef@*/
1022 for (cnt = 0; cnt < 16; ++cnt)
1023 sl_snprintf (&outbuf[cnt*2], 3, _("%02X"), /* known to fit */
1024 (unsigned int) md5buffer[cnt]);
1025 /*@+bufferoverflowhigh +usedef@*/
1026 for (cnt = 32; cnt < KEY_LEN; ++cnt)
1027 outbuf[cnt] = '0';
1028 outbuf[KEY_LEN] = '\0';
1029
1030 sl_strlcpy(out, outbuf, len);
1031 return out;
1032}
1033
1034/* USE_MD5 */
1035#endif
1036
1037/***************************************************************
1038 *
1039 * SHA1
1040 *
1041 ***************************************************************/
1042
1043#ifdef USE_SHA1
1044/*@-type@*/
1045
1046typedef unsigned char sha_word8;
1047typedef sh_word32 sha_word32;
1048
1049/* The SHA block size and message digest sizes, in bytes */
1050
1051#define SHA_DATASIZE 64
1052#define SHA_DATALEN 16
1053#define SHA_DIGESTSIZE 20
1054#define SHA_DIGESTLEN 5
1055/* The structure for storing SHA info */
1056
1057typedef struct sha_ctx {
1058 sha_word32 digest[SHA_DIGESTLEN]; /* Message digest */
1059 sha_word32 count_l, count_h; /* 64-bit block count */
1060 sha_word8 block[SHA_DATASIZE]; /* SHA data buffer */
1061 int index; /* index into buffer */
1062} SHA_CTX;
1063
1064static void sha_init(struct sha_ctx *ctx);
1065static void sha_update(struct sha_ctx *ctx, sha_word8 *buffer,sha_word32 len);
1066static void sha_final(struct sha_ctx *ctx);
1067static void sha_digest(struct sha_ctx *ctx, sha_word8 *s);
1068
1069
1070/* The SHA f()-functions. The f1 and f3 functions can be optimized to
1071 save one boolean operation each - thanks to Rich Schroeppel,
1072 rcs@cs.arizona.edu for discovering this */
1073
1074/*#define f1(x,y,z) ( ( x & y ) | ( ~x & z ) ) // Rounds 0-19 */
1075#define f1(x,y,z) ( z ^ ( x & ( y ^ z ) ) ) /* Rounds 0-19 */
1076#define f2(x,y,z) ( x ^ y ^ z ) /* Rounds 20-39 */
1077/*#define f3(x,y,z) ( ( x & y ) | ( x & z ) | ( y & z ) ) // Rounds 40-59 */
1078#define f3(x,y,z) ( ( x & y ) | ( z & ( x | y ) ) ) /* Rounds 40-59 */
1079#define f4(x,y,z) ( x ^ y ^ z ) /* Rounds 60-79 */
1080
1081/* The SHA Mysterious Constants */
1082
1083#define K1 0x5A827999L /* Rounds 0-19 */
1084#define K2 0x6ED9EBA1L /* Rounds 20-39 */
1085#define K3 0x8F1BBCDCL /* Rounds 40-59 */
1086#define K4 0xCA62C1D6L /* Rounds 60-79 */
1087
1088/* SHA initial values */
1089
1090#define h0init 0x67452301L
1091#define h1init 0xEFCDAB89L
1092#define h2init 0x98BADCFEL
1093#define h3init 0x10325476L
1094#define h4init 0xC3D2E1F0L
1095
1096/* 32-bit rotate left - kludged with shifts */
1097
1098#define ROTL(n,X) ( ( (X) << (n) ) | ( (X) >> ( 32 - (n) ) ) )
1099
1100/* The initial expanding function. The hash function is defined over an
1101 80-word expanded input array W, where the first 16 are copies of the input
1102 data, and the remaining 64 are defined by
1103
1104 W[ i ] = W[ i - 16 ] ^ W[ i - 14 ] ^ W[ i - 8 ] ^ W[ i - 3 ]
1105
1106 This implementation generates these values on the fly in a circular
1107 buffer - thanks to Colin Plumb, colin@nyx10.cs.du.edu for this
1108 optimization.
1109
1110 The updated SHA changes the expanding function by adding a rotate of 1
1111 bit. Thanks to Jim Gillogly, jim@rand.org, and an anonymous contributor
1112 for this information */
1113
1114#define expand(W,i) ( W[ i & 15 ] = \
1115 ROTL( 1, ( W[ i & 15 ] ^ W[ (i - 14) & 15 ] ^ \
1116 W[ (i - 8) & 15 ] ^ W[ (i - 3) & 15 ] ) ) )
1117
1118
1119/* The prototype SHA sub-round. The fundamental sub-round is:
1120
1121 a' = e + ROTL( 5, a ) + f( b, c, d ) + k + data;
1122 b' = a;
1123 c' = ROTL( 30, b );
1124 d' = c;
1125 e' = d;
1126
1127 but this is implemented by unrolling the loop 5 times and renaming the
1128 variables ( e, a, b, c, d ) = ( a', b', c', d', e' ) each iteration.
1129 This code is then replicated 20 times for each of the 4 functions, using
1130 the next 20 values from the W[] array each time */
1131
1132#define subRound(a, b, c, d, e, f, k, data) \
1133 ( e += ROTL( 5, a ) + f( b, c, d ) + k + data, b = ROTL( 30, b ) )
1134
1135/* Initialize the SHA values */
1136
1137static void sha_init(struct sha_ctx *ctx)
1138{
1139 /* Set the h-vars to their initial values */
1140 ctx->digest[ 0 ] = h0init;
1141 ctx->digest[ 1 ] = h1init;
1142 ctx->digest[ 2 ] = h2init;
1143 ctx->digest[ 3 ] = h3init;
1144 ctx->digest[ 4 ] = h4init;
1145
1146 /* Initialize bit count */
1147 ctx->count_l = ctx->count_h = 0;
1148
1149 /* Initialize buffer */
1150 ctx->index = 0;
1151}
1152
1153/* Perform the SHA transformation. Note that this code, like MD5, seems to
1154 break some optimizing compilers due to the complexity of the expressions
1155 and the size of the basic block. It may be necessary to split it into
1156 sections, e.g. based on the four subrounds
1157
1158 Note that this function destroys the data area */
1159
1160static void sha_transform(struct sha_ctx *ctx, sha_word32 *data )
1161{
1162 register sha_word32 A, B, C, D, E; /* Local vars */
1163
1164 /* Set up first buffer and local data buffer */
1165 A = ctx->digest[0];
1166 B = ctx->digest[1];
1167 C = ctx->digest[2];
1168 D = ctx->digest[3];
1169 E = ctx->digest[4];
1170
1171 /* Heavy mangling, in 4 sub-rounds of 20 interations each. */
1172 subRound( A, B, C, D, E, f1, K1, data[ 0] );
1173 subRound( E, A, B, C, D, f1, K1, data[ 1] );
1174 subRound( D, E, A, B, C, f1, K1, data[ 2] );
1175 subRound( C, D, E, A, B, f1, K1, data[ 3] );
1176 subRound( B, C, D, E, A, f1, K1, data[ 4] );
1177 subRound( A, B, C, D, E, f1, K1, data[ 5] );
1178 subRound( E, A, B, C, D, f1, K1, data[ 6] );
1179 subRound( D, E, A, B, C, f1, K1, data[ 7] );
1180 subRound( C, D, E, A, B, f1, K1, data[ 8] );
1181 subRound( B, C, D, E, A, f1, K1, data[ 9] );
1182 subRound( A, B, C, D, E, f1, K1, data[10] );
1183 subRound( E, A, B, C, D, f1, K1, data[11] );
1184 subRound( D, E, A, B, C, f1, K1, data[12] );
1185 subRound( C, D, E, A, B, f1, K1, data[13] );
1186 subRound( B, C, D, E, A, f1, K1, data[14] );
1187 subRound( A, B, C, D, E, f1, K1, data[15] );
1188 subRound( E, A, B, C, D, f1, K1, expand( data, 16 ) );
1189 subRound( D, E, A, B, C, f1, K1, expand( data, 17 ) );
1190 subRound( C, D, E, A, B, f1, K1, expand( data, 18 ) );
1191 subRound( B, C, D, E, A, f1, K1, expand( data, 19 ) );
1192
1193 subRound( A, B, C, D, E, f2, K2, expand( data, 20 ) );
1194 subRound( E, A, B, C, D, f2, K2, expand( data, 21 ) );
1195 subRound( D, E, A, B, C, f2, K2, expand( data, 22 ) );
1196 subRound( C, D, E, A, B, f2, K2, expand( data, 23 ) );
1197 subRound( B, C, D, E, A, f2, K2, expand( data, 24 ) );
1198 subRound( A, B, C, D, E, f2, K2, expand( data, 25 ) );
1199 subRound( E, A, B, C, D, f2, K2, expand( data, 26 ) );
1200 subRound( D, E, A, B, C, f2, K2, expand( data, 27 ) );
1201 subRound( C, D, E, A, B, f2, K2, expand( data, 28 ) );
1202 subRound( B, C, D, E, A, f2, K2, expand( data, 29 ) );
1203 subRound( A, B, C, D, E, f2, K2, expand( data, 30 ) );
1204 subRound( E, A, B, C, D, f2, K2, expand( data, 31 ) );
1205 subRound( D, E, A, B, C, f2, K2, expand( data, 32 ) );
1206 subRound( C, D, E, A, B, f2, K2, expand( data, 33 ) );
1207 subRound( B, C, D, E, A, f2, K2, expand( data, 34 ) );
1208 subRound( A, B, C, D, E, f2, K2, expand( data, 35 ) );
1209 subRound( E, A, B, C, D, f2, K2, expand( data, 36 ) );
1210 subRound( D, E, A, B, C, f2, K2, expand( data, 37 ) );
1211 subRound( C, D, E, A, B, f2, K2, expand( data, 38 ) );
1212 subRound( B, C, D, E, A, f2, K2, expand( data, 39 ) );
1213
1214 subRound( A, B, C, D, E, f3, K3, expand( data, 40 ) );
1215 subRound( E, A, B, C, D, f3, K3, expand( data, 41 ) );
1216 subRound( D, E, A, B, C, f3, K3, expand( data, 42 ) );
1217 subRound( C, D, E, A, B, f3, K3, expand( data, 43 ) );
1218 subRound( B, C, D, E, A, f3, K3, expand( data, 44 ) );
1219 subRound( A, B, C, D, E, f3, K3, expand( data, 45 ) );
1220 subRound( E, A, B, C, D, f3, K3, expand( data, 46 ) );
1221 subRound( D, E, A, B, C, f3, K3, expand( data, 47 ) );
1222 subRound( C, D, E, A, B, f3, K3, expand( data, 48 ) );
1223 subRound( B, C, D, E, A, f3, K3, expand( data, 49 ) );
1224 subRound( A, B, C, D, E, f3, K3, expand( data, 50 ) );
1225 subRound( E, A, B, C, D, f3, K3, expand( data, 51 ) );
1226 subRound( D, E, A, B, C, f3, K3, expand( data, 52 ) );
1227 subRound( C, D, E, A, B, f3, K3, expand( data, 53 ) );
1228 subRound( B, C, D, E, A, f3, K3, expand( data, 54 ) );
1229 subRound( A, B, C, D, E, f3, K3, expand( data, 55 ) );
1230 subRound( E, A, B, C, D, f3, K3, expand( data, 56 ) );
1231 subRound( D, E, A, B, C, f3, K3, expand( data, 57 ) );
1232 subRound( C, D, E, A, B, f3, K3, expand( data, 58 ) );
1233 subRound( B, C, D, E, A, f3, K3, expand( data, 59 ) );
1234
1235 subRound( A, B, C, D, E, f4, K4, expand( data, 60 ) );
1236 subRound( E, A, B, C, D, f4, K4, expand( data, 61 ) );
1237 subRound( D, E, A, B, C, f4, K4, expand( data, 62 ) );
1238 subRound( C, D, E, A, B, f4, K4, expand( data, 63 ) );
1239 subRound( B, C, D, E, A, f4, K4, expand( data, 64 ) );
1240 subRound( A, B, C, D, E, f4, K4, expand( data, 65 ) );
1241 subRound( E, A, B, C, D, f4, K4, expand( data, 66 ) );
1242 subRound( D, E, A, B, C, f4, K4, expand( data, 67 ) );
1243 subRound( C, D, E, A, B, f4, K4, expand( data, 68 ) );
1244 subRound( B, C, D, E, A, f4, K4, expand( data, 69 ) );
1245 subRound( A, B, C, D, E, f4, K4, expand( data, 70 ) );
1246 subRound( E, A, B, C, D, f4, K4, expand( data, 71 ) );
1247 subRound( D, E, A, B, C, f4, K4, expand( data, 72 ) );
1248 subRound( C, D, E, A, B, f4, K4, expand( data, 73 ) );
1249 subRound( B, C, D, E, A, f4, K4, expand( data, 74 ) );
1250 subRound( A, B, C, D, E, f4, K4, expand( data, 75 ) );
1251 subRound( E, A, B, C, D, f4, K4, expand( data, 76 ) );
1252 subRound( D, E, A, B, C, f4, K4, expand( data, 77 ) );
1253 subRound( C, D, E, A, B, f4, K4, expand( data, 78 ) );
1254 subRound( B, C, D, E, A, f4, K4, expand( data, 79 ) );
1255
1256 /* Build message digest */
1257 ctx->digest[0] += A;
1258 ctx->digest[1] += B;
1259 ctx->digest[2] += C;
1260 ctx->digest[3] += D;
1261 ctx->digest[4] += E;
1262}
1263
1264#if 1
1265
1266#ifndef EXTRACT_UCHAR
1267#define EXTRACT_UCHAR(p) (*(unsigned char *)(p))
1268#endif
1269
1270#define STRING2INT(s) ((((((EXTRACT_UCHAR(s) << 8) \
1271 | EXTRACT_UCHAR(s+1)) << 8) \
1272 | EXTRACT_UCHAR(s+2)) << 8) \
1273 | EXTRACT_UCHAR(s+3))
1274#else
1275sha_word32 STRING2INT(word8 *s)
1276{
1277 sha_word32 r;
1278 int i;
1279
1280 for (i = 0, r = 0; i < 4; i++, s++)
1281 r = (r << 8) | *s;
1282 return r;
1283}
1284#endif
1285
1286static void sha_block(struct sha_ctx *ctx, sha_word8 *block)
1287{
1288 sha_word32 data[SHA_DATALEN];
1289 int i;
1290
1291 /* Update block count */
1292 /*@-boolops@*/
1293 if (!++ctx->count_l)
1294 ++ctx->count_h;
1295 /*@+boolops@*/
1296
1297 /* Endian independent conversion */
1298 for (i = 0; i<SHA_DATALEN; i++, block += 4)
1299 data[i] = STRING2INT(block);
1300
1301 sha_transform(ctx, data);
1302}
1303
1304static void sha_update(struct sha_ctx *ctx, sha_word8 *buffer, sha_word32 len)
1305{
1306 if (ctx->index != 0)
1307 { /* Try to fill partial block */
1308 unsigned left = SHA_DATASIZE - ctx->index;
1309 if (len < left)
1310 {
1311 memmove(ctx->block + ctx->index, buffer, len);
1312 ctx->index += len;
1313 return; /* Finished */
1314 }
1315 else
1316 {
1317 memmove(ctx->block + ctx->index, buffer, left);
1318 sha_block(ctx, ctx->block);
1319 buffer += left;
1320 len -= left;
1321 }
1322 }
1323 while (len >= SHA_DATASIZE)
1324 {
1325 sha_block(ctx, buffer);
1326 buffer += SHA_DATASIZE;
1327 len -= SHA_DATASIZE;
1328 }
1329 /*@-predboolint@*/
1330 if ((ctx->index = len)) /* This assignment is intended */
1331 /*@+predboolint@*/
1332 /* Buffer leftovers */
1333 memmove(ctx->block, buffer, len);
1334}
1335
1336/* Final wrapup - pad to SHA_DATASIZE-byte boundary with the bit pattern
1337 1 0* (64-bit count of bits processed, MSB-first) */
1338
1339static void sha_final(struct sha_ctx *ctx)
1340{
1341 sha_word32 data[SHA_DATALEN];
1342 int i;
1343 int words;
1344
1345 i = ctx->index;
1346 /* Set the first char of padding to 0x80. This is safe since there is
1347 always at least one byte free */
1348 ctx->block[i++] = 0x80;
1349
1350 /* Fill rest of word */
1351 /*@-predboolint@*/
1352 for( ; i & 3; i++)
1353 ctx->block[i] = 0;
1354 /*@+predboolint@*/
1355
1356 /* i is now a multiple of the word size 4 */
1357 /*@-shiftimplementation@*/
1358 words = i >> 2;
1359 /*@+shiftimplementation@*/
1360 for (i = 0; i < words; i++)
1361 data[i] = STRING2INT(ctx->block + 4*i);
1362
1363 if (words > (SHA_DATALEN-2))
1364 { /* No room for length in this block. Process it and
1365 * pad with another one */
1366 for (i = words ; i < SHA_DATALEN; i++)
1367 data[i] = 0;
1368 sha_transform(ctx, data);
1369 for (i = 0; i < (SHA_DATALEN-2); i++)
1370 data[i] = 0;
1371 }
1372 else
1373 for (i = words ; i < SHA_DATALEN - 2; i++)
1374 data[i] = 0;
1375 /* Theres 512 = 2^9 bits in one block */
1376 /*@-shiftimplementation@*/
1377 data[SHA_DATALEN-2] = (ctx->count_h << 9) | (ctx->count_l >> 23);
1378 data[SHA_DATALEN-1] = (ctx->count_l << 9) | (ctx->index << 3);
1379 /*@+shiftimplementation@*/
1380 sha_transform(ctx, data);
1381}
1382
1383static void sha_digest(struct sha_ctx *ctx, sha_word8 *s)
1384{
1385 int i;
1386
1387 for (i = 0; i < SHA_DIGESTLEN; i++)
1388 {
1389 *s++ = ctx->digest[i] >> 24;
1390 *s++ = 0xff & (ctx->digest[i] >> 16);
1391 *s++ = 0xff & (ctx->digest[i] >> 8);
1392 *s++ = 0xff & ctx->digest[i];
1393 }
1394}
1395/*@+type@*/
1396
1397#include "sh_checksum.h"
1398
1399#define SH_VAR_SHA1 0
1400#define SH_VAR_SHA256 1
1401
1402/* Compute SHA1 message digest for bytes read from STREAM. The
1403 resulting message digest number will be written into the 16 bytes
1404 beginning at RESBLOCK. */
1405static int SHA_stream(char * filename, void *resblock,
1406 UINT64 * Length, int timeout, SL_TICKET fd, int variant)
1407{
1408 /* Important: BLOCKSIZE must be a multiple of 64. */
1409 static const int BLOCKSIZE = 4096;
1410 struct sha_ctx ctx;
1411 SHA256_CTX ctx_sha2;
1412 char * buffer = SH_ALLOC(4168); /* BLOCKSIZE + 72 AIX compiler chokes */
1413 off_t sum = 0;
1414 char * tmp;
1415 uid_t euid;
1416 UINT64 bcount = 0;
1417 sh_string * content;
1418
1419 unsigned long pages_read;
1420#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
1421 /*@-nestedextern@*/
1422 extern long IO_Limit;
1423 /*@+nestedextern@*/
1424#endif
1425
1426 /* Initialize the computation context. */
1427 if (variant == SH_VAR_SHA256)
1428 (void) SHA256_Init(&ctx_sha2);
1429 else
1430 (void) sha_init(&ctx);
1431
1432 if (SL_ISERROR (fd))
1433 {
1434 TPT((0, FIL__, __LINE__, _("msg=<SL_ISERROR (%ld)>\n"), fd));
1435 tmp = sh_util_safe_name (filename);
1436 (void) sl_get_euid(&euid);
1437 sh_error_handle (ShDFLevel[SH_ERR_T_FILE], FIL__, __LINE__, fd,
1438 MSG_E_ACCESS, (long) euid, tmp);
1439 SH_FREE(tmp);
1440 *Length = 0;
1441 SH_FREE(buffer);
1442 return -1;
1443 }
1444
1445 /* Iterate over full file contents. */
1446
1447 pages_read = 0;
1448
1449 content = sl_get_content(fd);
1450
1451 while (1 == 1) {
1452 /* We read the file in blocks of BLOCKSIZE bytes. One call of the
1453 computation function processes the whole buffer so that with the
1454 next round of the loop another block can be read. */
1455 off_t n;
1456 sum = 0;
1457
1458 /* Read block. Take care for partial reads. */
1459 do {
1460 n = (off_t) sl_read_timeout(fd, buffer + sum,
1461 (size_t) BLOCKSIZE - sum, timeout, S_FALSE);
1462
1463 if (SL_ISERROR (n))
1464 {
1465 int error = errno;
1466
1467 if (sig_termfast == 1)
1468 {
1469 SH_FREE(buffer);
1470 return -1;
1471 }
1472
1473 TPT((0, FIL__ , __LINE__ , _("msg=<SL_ISERROR (%ld)>\n"), n));
1474 tmp = sh_util_safe_name (filename);
1475 if (n == SL_TIMEOUT)
1476 {
1477 if (timeout != 7) {
1478 sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, n, MSG_E_TIMEOUT,
1479 timeout, tmp);
1480 }
1481 }
1482 else
1483 {
1484 char errbuf[SH_ERRBUF_SIZE];
1485 char errbuf2[SH_ERRBUF_SIZE];
1486 sl_strlcpy(errbuf, sl_error_string(n), sizeof(errbuf));
1487 sh_error_message(error, errbuf2, sizeof(errbuf2));
1488 sh_error_handle (ShDFLevel[SH_ERR_T_FILE], FIL__, __LINE__, n,
1489 MSG_E_READ, errbuf, errbuf2, tmp);
1490 }
1491 SH_FREE(tmp);
1492 *Length = 0;
1493 SH_FREE(buffer);
1494 return -1;
1495 }
1496
1497 if (content)
1498 sh_string_cat_lchar(content, buffer, n);
1499
1500 bcount += n;
1501
1502 if (*Length != TIGER_NOLIM)
1503 {
1504 if (bcount > *Length)
1505 {
1506 n = n - (bcount - (*Length));
1507 bcount = *Length;
1508 n = (n < 0) ? 0 : n;
1509 }
1510 }
1511
1512 sum += n;
1513 }
1514 while (sum < (off_t)BLOCKSIZE
1515 && n != 0);
1516
1517 ++pages_read;
1518
1519 /* If end of file is reached, end the loop. */
1520 if (n == 0)
1521 break;
1522
1523 /* Process buffer with BLOCKSIZE bytes. Note that
1524 BLOCKSIZE % 64 == 0
1525 */
1526 if (variant == SH_VAR_SHA256)
1527 SHA256_Update(&ctx_sha2, (sha2_byte*) buffer, (size_t) BLOCKSIZE);
1528 else
1529 sha_update(&ctx, (sha_word8*) buffer, (sha_word32) BLOCKSIZE);
1530 sh.statistics.bytes_hashed += BLOCKSIZE;
1531
1532#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
1533 if ((IO_Limit) > 0 && (pages_read == 32)) /* check for I/O limit */
1534 {
1535 sh_unix_io_pause ();
1536 pages_read = 0;
1537 }
1538 if (sig_termfast == 1)
1539 {
1540 *Length = 0;
1541 SH_FREE(buffer);
1542 return -1;
1543 }
1544#endif
1545
1546 }
1547
1548 /* Add the last bytes if necessary. */
1549 if (sum > 0)
1550 {
1551 if (variant == SH_VAR_SHA256)
1552 SHA256_Update(&ctx_sha2, (sha2_byte*) buffer, (size_t) sum);
1553 else
1554 sha_update(&ctx, (sha_word8*) buffer, (sha_word32) sum);
1555 sh.statistics.bytes_hashed += sum;
1556 }
1557
1558 /* Construct result in desired memory. */
1559 if (variant == SH_VAR_SHA256)
1560 {
1561 SHA256_End(&ctx_sha2, resblock);
1562 }
1563 else
1564 {
1565 sha_final (&ctx);
1566 sha_digest (&ctx, resblock);
1567 }
1568
1569 *Length = bcount;
1570 SH_FREE(buffer);
1571 return 0;
1572}
1573
1574
1575static char * sh_tiger_sha1_hash (char * filename, TigerType what,
1576 UINT64 * Length, int timeout,
1577 char * out, size_t len)
1578{
1579 int cnt;
1580 char outbuf[KEY_LEN+1];
1581 unsigned char sha1buffer[20];
1582
1583 (void) SHA_stream (filename, sha1buffer, Length, timeout, what, SH_VAR_SHA1);
1584
1585 /*@-bufferoverflowhigh -usedef@*/
1586 for (cnt = 0; cnt < 20; ++cnt)
1587 sl_snprintf (&outbuf[cnt*2], 3, _("%02X"), /* known to fit */
1588 (unsigned int) sha1buffer[cnt]);
1589 /*@+bufferoverflowhigh +usedef@*/
1590 for (cnt = 40; cnt < KEY_LEN; ++cnt)
1591 outbuf[cnt] = '0';
1592 outbuf[KEY_LEN] = '\0';
1593
1594 sl_strlcpy(out, outbuf, len);
1595 return out;
1596}
1597
1598static char * sh_tiger_sha256_hash (char * filename, TigerType what,
1599 UINT64 * Length, int timeout,
1600 char * out, size_t len)
1601{
1602 char outbuf[KEYBUF_SIZE];
1603
1604 (void) SHA_stream (filename, outbuf, Length, timeout, what, SH_VAR_SHA256);
1605
1606 sl_strlcpy(out, outbuf, len);
1607 return out;
1608}
1609
1610/* ifdef USE_SHA1 */
1611#endif
1612
1613static int hash_type = SH_TIGER192;
1614
1615int sh_tiger_get_hashtype ()
1616{
1617 return hash_type;
1618}
1619
1620void sh_tiger_get_mask_hashtype(unsigned long * mask)
1621{
1622 if (hash_type == SH_TIGER192)
1623 *mask |= MODI_TIGER192;
1624 else if (hash_type == SH_SHA1)
1625 *mask |= MODI_SHA1;
1626 else if (hash_type == SH_MD5)
1627 *mask |= MODI_MD5;
1628 else if (hash_type == SH_SHA256)
1629 *mask |= MODI_SHA256;
1630 return;
1631}
1632
1633void sh_tiger_set_hashtype_mask(unsigned long mask)
1634{
1635 unsigned long type = mask & MODI_HASHTYPE;
1636
1637 if (type == MODI_TIGER192)
1638 hash_type = SH_TIGER192;
1639 else if (type == MODI_SHA1)
1640 hash_type = SH_SHA1;
1641 else if (type == MODI_MD5)
1642 hash_type = SH_MD5;
1643 else if (type == MODI_SHA256)
1644 hash_type = SH_SHA256;
1645 return;
1646}
1647
1648
1649int sh_tiger_hashtype (const char * c)
1650{
1651 SL_ENTER( _("sh_tiger_hashtype"));
1652
1653 if (!c)
1654 {
1655 SL_RETURN( -1, _("sh_tiger_hashtype"));
1656 }
1657
1658 if (0 == strcmp(c, _("TIGER192")))
1659 hash_type = SH_TIGER192;
1660#ifdef USE_SHA1
1661 else if (0 == strcmp(c, _("SHA1")))
1662 hash_type = SH_SHA1;
1663#endif
1664#ifdef USE_MD5
1665 else if (0 == strcmp(c, _("MD5")))
1666 hash_type = SH_MD5;
1667#endif
1668#ifdef USE_SHA1
1669 else if (0 == strcmp(c, _("SHA256")))
1670 hash_type = SH_SHA256;
1671#endif
1672 else
1673 {
1674 SL_RETURN( -1, _("sh_tiger_hashtype"));
1675 }
1676 SL_RETURN( 0, _("sh_tiger_hashtype"));
1677}
1678
1679static char * sh_tiger_hash_internal (const char * filename, TigerType what,
1680 UINT64 * Length, int timeout,
1681 char * out, size_t len);
1682
1683char * sh_tiger_hash (const char * filename, TigerType what,
1684 UINT64 Length, char * out, size_t len)
1685{
1686 UINT64 local_length = Length;
1687 char * retval = sh_tiger_hash_internal (filename, what, &local_length, 0, out,len);
1688 return retval;
1689}
1690
1691char * sh_tiger_generic_hash (char * filename, TigerType what,
1692 UINT64 * Length, int timeout,
1693 char * out, size_t len)
1694{
1695#ifdef USE_SHA1
1696 if (hash_type == SH_SHA1)
1697 return sh_tiger_sha1_hash (filename, what, Length, timeout, out, len);
1698#endif
1699#ifdef USE_MD5
1700 if (hash_type == SH_MD5)
1701 return sh_tiger_md5_hash (filename, what, Length, timeout, out, len);
1702#endif
1703#ifdef USE_SHA1
1704 if (hash_type == SH_SHA256)
1705 return sh_tiger_sha256_hash (filename, what, Length, timeout, out, len);
1706#endif
1707 return sh_tiger_hash_internal (filename, what, Length, timeout, out, len);
1708}
1709
1710/*
1711 * ------- end new --------- */
1712
1713static char * sh_tiger_hash_internal (const char * filename, TigerType what,
1714 UINT64 * Length, int timeout,
1715 char * out, size_t len)
1716{
1717#if defined(TIGER_64_BIT)
1718 word64 res[3];
1719#else
1720 sh_word32 res[6];
1721#endif
1722
1723 SL_ENTER( _("sh_tiger_hash_internal"));
1724
1725 SH_VALIDATE_GE(len, (KEY_LEN+1));
1726
1727 if (NULL != sh_tiger_hash_val (filename, what, Length, timeout, res))
1728 {
1729#if defined(TIGER_64_BIT)
1730 sl_snprintf(out, len,
1731 MYFORMAT,
1732 (sh_word32)(res[0]>>32),
1733 (sh_word32)(res[0]),
1734 (sh_word32)(res[1]>>32),
1735 (sh_word32)(res[1]),
1736 (sh_word32)(res[2]>>32),
1737 (sh_word32)(res[2]) );
1738#else
1739 sl_snprintf(out, len,
1740 MYFORMAT,
1741 (sh_word32)(res[1]),
1742 (sh_word32)(res[0]),
1743 (sh_word32)(res[3]),
1744 (sh_word32)(res[2]),
1745 (sh_word32)(res[5]),
1746 (sh_word32)(res[4]) );
1747#endif
1748 out[len-1] = '\0';
1749 SL_RETURN( out, _("sh_tiger_hash_internal"));
1750
1751 }
1752
1753 SL_RETURN( SH_KEY_NULL, _("sh_tiger_hash_internal"));
1754}
1755
1756char * sh_tiger_hash_gpg (const char * filename, TigerType what,
1757 UINT64 Length)
1758{
1759 size_t len;
1760 char * out;
1761 char outhash[48+6+1];
1762#if defined(TIGER_64_BIT)
1763 word64 res[3];
1764#else
1765 sh_word32 res[6];
1766#endif
1767 UINT64 local_length = Length;
1768
1769 SL_ENTER(_("sh_tiger_hash_gpg"));
1770
1771 if (NULL != sh_tiger_hash_val (filename, what, &local_length, 0, res))
1772 {
1773#if defined(TIGER_64_BIT)
1774 sl_snprintf(outhash,
1775 sizeof(outhash),
1776 GPGFORMAT,
1777 (sh_word32)(res[0]>>32),
1778 (sh_word32)(res[0]),
1779 (sh_word32)(res[1]>>32),
1780 (sh_word32)(res[1]),
1781 (sh_word32)(res[2]>>32),
1782 (sh_word32)(res[2]) );
1783#else
1784 sl_snprintf(outhash,
1785 sizeof(outhash),
1786 GPGFORMAT,
1787 (sh_word32)(res[1]),
1788 (sh_word32)(res[0]),
1789 (sh_word32)(res[3]),
1790 (sh_word32)(res[2]),
1791 (sh_word32)(res[5]),
1792 (sh_word32)(res[4]) );
1793#endif
1794 outhash[sizeof(outhash)-1] = '\0';
1795 }
1796 else
1797 {
1798 sl_strlcpy(outhash,
1799 _("00000000 00000000 00000000 00000000 00000000 00000000"),
1800 sizeof(outhash));
1801 }
1802
1803 if (what == TIGER_FILE && sl_ok_adds(sl_strlen (filename), (2 + 48 + 6)))
1804 len = sl_strlen (filename) + 2 + 48 + 6;
1805 else
1806 len = 48 + 6;
1807
1808 out = SH_ALLOC(len + 1);
1809
1810 if (what == TIGER_FILE)
1811 {
1812 (void) sl_strlcpy (out, filename, len+1);
1813 (void) sl_strlcat (out, _(": "), len+1);
1814 (void) sl_strlcat (out, outhash, len+1);
1815 }
1816 else
1817 {
1818 (void) sl_strlcpy (out, outhash, len+1);
1819 }
1820 SL_RETURN( out, _("sh_tiger_hash_gpg"));
1821}
1822
1823
1824UINT32 * sh_tiger_hash_uint32 (char * filename,
1825 TigerType what,
1826 UINT64 Length, UINT32 * out, size_t len)
1827{
1828#if defined(TIGER_64_BIT)
1829 word64 res[3];
1830#else
1831 sh_word32 res[6];
1832#endif
1833 UINT64 local_length = Length;
1834
1835 SL_ENTER(_("sh_tiger_hash_uint32"));
1836
1837 SH_VALIDATE_GE(len, 6);
1838
1839 out[0] = 0; out[1] = 0; out[2] = 0;
1840 out[3] = 0; out[4] = 0; out[5] = 0;
1841
1842 if (NULL != sh_tiger_hash_val (filename, what, &local_length, 0, res))
1843 {
1844#if defined(TIGER_64_BIT)
1845 out[0] = (UINT32)(res[0]>>32);
1846 out[1] = (UINT32)(res[0]);
1847 out[2] = (UINT32)(res[1]>>32);
1848 out[3] = (UINT32)(res[1]);
1849 out[4] = (UINT32)(res[2]>>32);
1850 out[5] = (UINT32)(res[2]);
1851#else
1852 out[0] = (UINT32)(res[1]);
1853 out[1] = (UINT32)(res[0]);
1854 out[2] = (UINT32)(res[3]);
1855 out[3] = (UINT32)(res[2]);
1856 out[4] = (UINT32)(res[5]);
1857 out[5] = (UINT32)(res[4]);
1858#endif
1859 }
1860
1861 SL_RETURN(out, _("sh_tiger_hash_uint32"));
1862}
1863
1864
1865
1866
Note: See TracBrowser for help on using the repository browser.