source: trunk/src/sh_tiger0.c @ 131

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

Use thread-safe libc functions.

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