source: trunk/src/sh_tiger0.c @ 133

Last change on this file since 133 was 133, checked in by rainer, 12 years ago

Reentrant checksum/hash functions.

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