Changeset 133


Ignore:
Timestamp:
Oct 25, 2007, 12:19:05 AM (12 years ago)
Author:
rainer
Message:

Reentrant checksum/hash functions.

Location:
trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/samhain.h

    r132 r133  
    6262#define KEY_LEN   48
    6363#define KEY_BLOCK 24
     64#define KEYBUF_SIZE (KEY_LEN+1)
    6465
    6566/* The length of the compiled-in password.
  • trunk/include/sh_pthread.h

    r132 r133  
    2626#define SH_MUTEX_UNLOCK_UNSAFE(M) pthread_mutex_unlock(&(M))
    2727
     28/*
     29 * ----   Global mutexes   ----
     30 */
     31SH_MUTEX_EXTERN(mutex_skey);
     32
    2833#else
    2934
  • trunk/include/sh_srp.h

    r1 r133  
    2121void sh_srp_x (char * salt, char * password);
    2222int  sh_srp_make_a (void);
    23 char * sh_srp_M (char * x1, char * x2, char * x3);
     23char * sh_srp_M (char * x1, char * x2, char * x3, char * buf, size_t size);
    2424
    2525char * sh_srp_verifier (void);
  • trunk/include/sh_tiger.h

    r107 r133  
    77#include "samhain.h"
    88
     9typedef long int TigerType;
     10
     11#define TIGER_FILE -1;
     12#define TIGER_DATA -2;
     13
     14/****************
    915typedef enum {
    1016  TIGER_FILE,
     
    1218  TIGER_DATA
    1319} TigerType;
     20*****************/
    1421
    1522#define TIGER_NOLIM ((UINT64)-1)
    16 
    17 extern SL_TICKET tiger_fd;
    1823
    1924/* the checksum function
    2025 */
    2126/*@owned@*/ char * sh_tiger_hash (const char * filename, TigerType what,
    22                                   UINT64 Length);
     27                                  UINT64 Length, char * out, size_t len);
    2328
    2429/* NEW Thu Oct 18 19:59:08 CEST 2001
     
    2631int sh_tiger_hashtype (const char * c);
    2732char * sh_tiger_generic_hash (char * filename, TigerType what,
    28                               UINT64 Length, int timeout);
     33                              UINT64 Length, int timeout,
     34                              char * out, size_t len);
    2935
    3036UINT32 * sh_tiger_hash_uint32 (char * filename,
    3137                               TigerType what,
    32                                UINT64 Length);
     38                               UINT64 Length, UINT32 * out, size_t len);
    3339
    3440/* get the type of hash function used
     
    3743int sh_tiger_get_hashtype ();
    3844
    39 /* GnuPG-like format
     45/* GnuPG-like format, returns allocated memory
    4046 */
    4147/*@owned@*/ char * sh_tiger_hash_gpg (const char * filename, TigerType what,
  • trunk/src/cutest_sh_tiger0.c

    r107 r133  
    6767  char * actual;
    6868  char * expected;
     69  char hashbuf[KEYBUF_SIZE];
    6970
    7071  input  = "";
    71   actual = sh_tiger_hash(input, TIGER_DATA, strlen(input));
     72  actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
    7273  expected = "24F0130C63AC933216166E76B1BB925FF373DE2D49584E7A";
    7374  CuAssertStrEquals(tc, expected, actual);
    7475
    7576  input  = "abc";
    76   actual = sh_tiger_hash(input, TIGER_DATA, strlen(input));
     77  actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
    7778  expected = "F258C1E88414AB2A527AB541FFC5B8BF935F7B951C132951";
    7879  CuAssertStrEquals(tc, expected, actual);
    7980 
    8081  input  = "Tiger";
    81   actual = sh_tiger_hash(input, TIGER_DATA, strlen(input));
     82  actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
    8283  expected = "9F00F599072300DD276ABB38C8EB6DEC37790C116F9D2BDF";
    8384  CuAssertStrEquals(tc, expected, actual);
    8485 
    8586  input  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-";
    86   actual = sh_tiger_hash(input, TIGER_DATA, strlen(input));
     87  actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
    8788  expected = "87FB2A9083851CF7470D2CF810E6DF9EB586445034A5A386";
    8889  CuAssertStrEquals(tc, expected, actual);
    8990 
    9091  input  = "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdefghijklmnopqrstuvwxyz+0123456789";
    91   actual = sh_tiger_hash(input, TIGER_DATA, strlen(input));
     92  actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
    9293  expected = "467DB80863EBCE488DF1CD1261655DE957896565975F9197";
    9394  CuAssertStrEquals(tc, expected, actual);
    9495 
    9596  input  = "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham";
    96   actual = sh_tiger_hash(input, TIGER_DATA, strlen(input));
     97  actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
    9798  expected = "0C410A042968868A1671DA5A3FD29A725EC1E457D3CDB303";
    9899  CuAssertStrEquals(tc, expected, actual);
    99100 
    100101  input  = "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham, proceedings of Fast Software Encryption 3, Cambridge.";
    101   actual = sh_tiger_hash(input, TIGER_DATA, strlen(input));
     102  actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
    102103  expected = "EBF591D5AFA655CE7F22894FF87F54AC89C811B6B0DA3193";
    103104  CuAssertStrEquals(tc, expected, actual);
    104105 
    105106  input  = "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham, proceedings of Fast Software Encryption 3, Cambridge, 1996.";
    106   actual = sh_tiger_hash(input, TIGER_DATA, strlen(input));
     107  actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
    107108  expected = "3D9AEB03D1BD1A6357B2774DFD6D5B24DD68151D503974FC";
    108109  CuAssertStrEquals(tc, expected, actual);
    109110 
    110111  input  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-";
    111   actual = sh_tiger_hash(input, TIGER_DATA, strlen(input));
     112  actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
    112113  expected = "00B83EB4E53440C576AC6AAEE0A7485825FD15E70A59FFE4";
    113114  CuAssertStrEquals(tc, expected, actual);
     
    121122  char * actual;
    122123  char * expected;
     124  char hashbuf[KEYBUF_SIZE];
    123125
    124126  init();
     
    139141  /* same result as GnuPG 1.0.6 (gpg --load-extension tiger --print-md TIGER192)
    140142   */
    141   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, TIGER_NOLIM, 0);
     143  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, TIGER_NOLIM, 0, hashbuf, sizeof(hashbuf));
    142144  expected = "0E9321614C966A33608C2A15F156E0435CACFD1213B9F095";
    143145  CuAssertStrEquals(tc, expected, actual);
     
    145147  rval_open = sl_open_fastread ("cutest_foo", SL_YESPRIV);
    146148  CuAssertTrue(tc, rval_open >= 0);
    147   tiger_fd  = rval_open;
    148 
    149   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, TIGER_NOLIM, 0);
     149
     150  actual = sh_tiger_generic_hash("cutest_foo", rval_open, TIGER_NOLIM, 0, hashbuf, sizeof(hashbuf));
    150151  expected = "0E9321614C966A33608C2A15F156E0435CACFD1213B9F095";
    151152  CuAssertStrEquals(tc, expected, actual);
     
    159160  rval_open = sl_open_fastread ("cutest_foo", SL_YESPRIV);
    160161  CuAssertTrue(tc, rval_open >= 0);
    161   tiger_fd  = rval_open;
    162162
    163163  /* same result as GNU md5sum
    164164   */
    165   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, TIGER_NOLIM, 0);
     165  actual = sh_tiger_generic_hash("cutest_foo", rval_open, TIGER_NOLIM, 0, hashbuf, sizeof(hashbuf));
    166166  expected = "AEEC4DDA496BCFBA691F4E8863BA84C00000000000000000";
    167167  CuAssertStrEquals(tc, expected, actual);
     
    175175  rval_open = sl_open_fastread ("cutest_foo", SL_YESPRIV);
    176176  CuAssertTrue(tc, rval_open >= 0);
    177   tiger_fd  = rval_open;
    178177
    179178  /* same result as gpg --print-md SHA1
    180179   */
    181   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, TIGER_NOLIM, 0);
     180  actual = sh_tiger_generic_hash("cutest_foo", rval_open, TIGER_NOLIM, 0, hashbuf, sizeof(hashbuf));
    182181  expected = "2FE65D1D995B8F8BC8B13F798C07E7E935A787ED00000000";
    183182  CuAssertStrEquals(tc, expected, actual);
     
    205204  /* same result as GnuPG 1.0.6 (gpg --load-extension tiger --print-md TIGER192)
    206205   */
    207   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, TIGER_NOLIM, 0);
     206  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, TIGER_NOLIM, 0, hashbuf, sizeof(hashbuf));
    208207  expected = "F987845A0EA784367BF9E4DB09014995810F27C99C891734";
    209208  CuAssertStrEquals(tc, expected, actual);
     
    228227  /* same result as GnuPG 1.0.6 (gpg --load-extension tiger --print-md TIGER192)
    229228   */
    230   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, TIGER_NOLIM, 0);
     229  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, TIGER_NOLIM, 0, hashbuf, sizeof(hashbuf));
    231230  expected = "75B98A7AE257A230189828A40792E30B4038D286479CC7B8";
    232231  CuAssertStrEquals(tc, expected, actual);
     
    246245  char * actual;
    247246  char * expected;
     247  char hashbuf[KEYBUF_SIZE];
    248248
    249249  char * teststring = "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham, proceedings of Fast Software Encryption 3, Cambridge, 1996.\n";
     
    268268  /* same as GnuPG 1.0.6 (gpg --load-extension tiger --print-md TIGER192)
    269269   */
    270   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 0, 0);
     270  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 0, 0, hashbuf, sizeof(hashbuf));
    271271  expected = "24F0130C63AC933216166E76B1BB925FF373DE2D49584E7A";
    272272  CuAssertStrEquals(tc, expected, actual);
    273273
    274   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, testlen, 0);
     274  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, testlen, 0, hashbuf, sizeof(hashbuf));
    275275  expected = "75B98A7AE257A230189828A40792E30B4038D286479CC7B8";
    276276  CuAssertStrEquals(tc, expected, actual);
    277277
    278   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 2*testlen, 0);
     278  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 2*testlen, 0, hashbuf, sizeof(hashbuf));
    279279  expected = "B5B4FB97B01ADB58794D87A6A01B2368852FA764BD93AB90";
    280280  CuAssertStrEquals(tc, expected, actual);
    281281
    282   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, TIGER_NOLIM, 0);
     282  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, TIGER_NOLIM, 0, hashbuf, sizeof(hashbuf));
    283283  expected = "B5B4FB97B01ADB58794D87A6A01B2368852FA764BD93AB90";
    284284  CuAssertStrEquals(tc, expected, actual);
     
    291291  CuAssertTrue(tc, result == 0);
    292292
    293   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, testlen, 0);
     293  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, testlen, 0, hashbuf, sizeof(hashbuf));
    294294  expected = "75B98A7AE257A230189828A40792E30B4038D286479CC7B8";
    295295  CuAssertStrEquals(tc, expected, actual);
    296296
    297   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 2*testlen, 0);
     297  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 2*testlen, 0, hashbuf, sizeof(hashbuf));
    298298  expected = "B5B4FB97B01ADB58794D87A6A01B2368852FA764BD93AB90";
    299299  CuAssertStrEquals(tc, expected, actual);
    300300
    301   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 3*testlen, 0);
     301  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 3*testlen, 0, hashbuf, sizeof(hashbuf));
    302302  expected = "D0EE1A9956CAB22D84B51A5E0C093B724828C6A1F9CBDB7F";
    303303  CuAssertStrEquals(tc, expected, actual);
    304304
    305   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, TIGER_NOLIM, 0);
     305  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, TIGER_NOLIM, 0, hashbuf, sizeof(hashbuf));
    306306  expected = "D0EE1A9956CAB22D84B51A5E0C093B724828C6A1F9CBDB7F";
    307307  CuAssertStrEquals(tc, expected, actual);
    308308
    309   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 5, 0);
     309  actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, 5, 0, hashbuf, sizeof(hashbuf));
    310310  expected = "9F00F599072300DD276ABB38C8EB6DEC37790C116F9D2BDF";
    311311  CuAssertStrEquals(tc, expected, actual);
     
    318318  rval_open = sl_open_fastread ("cutest_foo", SL_YESPRIV);
    319319  CuAssertTrue(tc, rval_open >= 0);
    320   tiger_fd  = rval_open;
    321 
    322   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, testlen, 0);
     320
     321  actual = sh_tiger_generic_hash("cutest_foo", rval_open, testlen, 0, hashbuf, sizeof(hashbuf));
    323322  expected = "11E7E7EA486136273606BEE57C71F34B0000000000000000";
    324323  CuAssertStrEquals(tc, expected, actual);
     
    327326  CuAssertTrue(tc, rval_open >= 0);
    328327
    329   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, 2*testlen, 0);
     328  actual = sh_tiger_generic_hash("cutest_foo", rval_open, 2*testlen, 0, hashbuf, sizeof(hashbuf));
    330329  expected = "D49DAD474095D467E2E5EFCB2DC23A770000000000000000";
    331330  CuAssertStrEquals(tc, expected, actual);
     
    334333  CuAssertTrue(tc, rval_open >= 0);
    335334
    336   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, 3*testlen, 0);
     335  actual = sh_tiger_generic_hash("cutest_foo", rval_open, 3*testlen, 0, hashbuf, sizeof(hashbuf));
    337336  expected = "00A1F1C5EDDCCFC430D3862FDA94593E0000000000000000";
    338337  CuAssertStrEquals(tc, expected, actual);
     
    341340  CuAssertTrue(tc, rval_open >= 0);
    342341
    343   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, TIGER_NOLIM, 0);
     342  actual = sh_tiger_generic_hash("cutest_foo", rval_open, TIGER_NOLIM, 0, hashbuf, sizeof(hashbuf));
    344343  expected = "00A1F1C5EDDCCFC430D3862FDA94593E0000000000000000";
    345344  CuAssertStrEquals(tc, expected, actual);
     
    354353  CuAssertTrue(tc, rval_open >= 0);
    355354
    356   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, testlen, 0);
     355  actual = sh_tiger_generic_hash("cutest_foo", rval_open, testlen, 0, hashbuf, sizeof(hashbuf));
    357356  expected = "F37DB4344CCD140EE315179E9A27512FB4704F0F00000000";
    358357  CuAssertStrEquals(tc, expected, actual);
     
    361360  CuAssertTrue(tc, rval_open >= 0);
    362361
    363   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, 2*testlen, 0);
     362  actual = sh_tiger_generic_hash("cutest_foo", rval_open, 2*testlen, 0, hashbuf, sizeof(hashbuf));
    364363  expected = "D2AD5FC366452D81400BAC31F96269DEEF314BC200000000";
    365364  CuAssertStrEquals(tc, expected, actual);
     
    368367  CuAssertTrue(tc, rval_open >= 0);
    369368
    370   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, 3*testlen, 0);
     369  actual = sh_tiger_generic_hash("cutest_foo", rval_open, 3*testlen, 0, hashbuf, sizeof(hashbuf));
    371370  expected = "FAA937EF3389C7E786EB0F1006D049D7AEA7B7B600000000";
    372371  CuAssertStrEquals(tc, expected, actual);
     
    375374  CuAssertTrue(tc, rval_open >= 0);
    376375
    377   actual = sh_tiger_generic_hash("cutest_foo", TIGER_FD, TIGER_NOLIM, 0);
     376  actual = sh_tiger_generic_hash("cutest_foo", rval_open, TIGER_NOLIM, 0, hashbuf, sizeof(hashbuf));
    378377  expected = "FAA937EF3389C7E786EB0F1006D049D7AEA7B7B600000000";
    379378  CuAssertStrEquals(tc, expected, actual);
  • trunk/src/samhain.c

    r131 r133  
    14111411      if (0 != sl_strcmp(file_path('D', 'R'), _("REQ_FROM_SERVER")))
    14121412        {
     1413          char hashbuf[KEYBUF_SIZE];
    14131414          (void) sl_strlcpy(sh.data.hash,
    14141415                            sh_tiger_hash (file_path('D', 'R'),
    1415                                            TIGER_FILE, 0),
     1416                                           TIGER_FILE, 0,
     1417                                           hashbuf, sizeof(hashbuf)),
    14161418                            KEY_LEN+1);
    14171419        }
  • trunk/src/sh_entropy.c

    r132 r133  
    315315  int    i, m_count = 0;
    316316  char * keybuf;
     317  UINT32 kbuf[KEY_BYT/sizeof(UINT32)];
    317318  char   addbuf[2 * KEY_BYT];
    318319
     
    366367        addbuf[i+KEY_BYT] = skey->poolv[i];
    367368      keybuf = (char *) sh_tiger_hash_uint32 (addbuf,
    368                                               TIGER_DATA, 2 * KEY_BYT);
     369                                              TIGER_DATA, 2 * KEY_BYT,
     370                                              kbuf, KEY_BYT/sizeof(UINT32));
    369371      memset(addbuf, '\0', sizeof(addbuf));
    370372     
     
    701703
    702704  char * keybuf;
     705  UINT32 kbuf[KEY_BYT/sizeof(UINT32)];
    703706  char   addbuf[2 * KEY_BYT];
    704707
     
    885888    {
    886889      keybuf = (char *) sh_tiger_hash_uint32 (buffer,
    887                                               TIGER_DATA, sl_strlen(buffer));
     890                                              TIGER_DATA, sl_strlen(buffer),
     891                                              kbuf, KEY_BYT/sizeof(UINT32));
    888892
    889893      /* add previous entropy into the new pool
     
    896900        }
    897901      keybuf = (char *) sh_tiger_hash_uint32 (addbuf,
    898                                               TIGER_DATA, sizeof(addbuf));
     902                                              TIGER_DATA, sizeof(addbuf),
     903                                              kbuf, KEY_BYT/sizeof(UINT32));
    899904      memset(addbuf, '\0', sizeof(addbuf));
    900905     
  • trunk/src/sh_err_log.c

    r132 r133  
    145145  char c_cont;
    146146  int  chk_mode = CHK_KEY;
     147  char hashbuf[KEYBUF_SIZE];
    147148
    148149  sh_error_logoff();
     
    383384                    {
    384385                      (void) sl_strlcpy(key,
    385                                         sh_tiger_hash(NULL, TIGER_DATA, 0),
     386                                        sh_tiger_hash(NULL, TIGER_DATA, 0,
     387                                                      hashbuf, sizeof(hashbuf)),
    386388                                        KEY_LEN+1);
    387389                      chk_mode = CHK_NON;
     
    428430           */
    429431          (void) sl_strlcpy (key,
    430                              sh_tiger_hash (key, TIGER_DATA, KEY_LEN),
     432                             sh_tiger_hash (key, TIGER_DATA, KEY_LEN,
     433                                            hashbuf, sizeof(hashbuf)),
    431434                             KEY_LEN+1);
    432435        }
     
    440443      status = sl_strncmp (signature,
    441444                           sh_tiger_hash (buf, TIGER_DATA,
    442                                           (unsigned long) sl_strlen(buf)),
     445                                          (unsigned long) sl_strlen(buf),
     446                                          hashbuf, sizeof(hashbuf)),
    443447                           KEY_LEN);
    444448     
     
    861865  if (current->log_start == S_TRUE)
    862866    {
     867      char hashbuf[KEYBUF_SIZE];
     868
    863869      if (sh.real.user[0] == '\0')
    864870        (void) sh_unix_getUser();
     
    871877       */
    872878      (void) sl_strlcpy(sigkey_new,
    873                         sh_tiger_hash (sigkey_old, TIGER_DATA, KEY_LEN),
     879                        sh_tiger_hash (sigkey_old, TIGER_DATA, KEY_LEN,
     880                                       hashbuf, sizeof(hashbuf)),
    874881                        KEY_LEN+1);
    875882
  • trunk/src/sh_error.c

    r132 r133  
    124124{
    125125  char * foo;
     126  char hashbuf[KEYBUF_SIZE];
    126127
    127128  if (s[0] == '/')
     
    135136      fprintf (stdout, _("string=<%s>, hash=<%s>\n"),
    136137               s, sh_tiger_hash (s, TIGER_DATA,
    137                                  (unsigned long) sl_strlen(s)));
     138                                 (unsigned long) sl_strlen(s),
     139                                 hashbuf, sizeof(hashbuf))
     140               );
    138141    }
    139142  (void) fflush(stdout);
  • trunk/src/sh_extern.c

    r132 r133  
    184184  if (task->checksum[0]  != '\0')
    185185    {
     186      char hashbuf[KEYBUF_SIZE];
    186187      PDBG_S("checksum test");
    187188      if (0 != sl_strcmp(task->checksum,
    188                          sh_tiger_hash (task->command, TIGER_FILE, 0))
     189                         sh_tiger_hash (task->command, TIGER_FILE, 0,
     190                                        hashbuf, sizeof(hashbuf))
     191                         )
    189192          )
    190193        {
     
    354357              else
    355358                {
     359                  char hashbuf[KEYBUF_SIZE];
     360
    356361                  fd =
    357362                    sl_open_read(task->command,
    358363                                 task->privileged==0 ? SL_NOPRIV : SL_YESPRIV);
    359                   tiger_fd = fd;
     364
    360365                  if (0 != sl_strcmp(task->checksum,
    361366                                     sh_tiger_hash (task->command,
    362                                                     TIGER_FD, 0)))
     367                                                    fd, 0, hashbuf, sizeof(hashbuf))))
    363368                    {
    364369                      PDBGC_S("fexecve: checksum mismatch");
  • trunk/src/sh_forward.c

    r132 r133  
    890890
    891891  static time_t timeout_val =  1;
     892  char hashbuf[KEYBUF_SIZE];
     893  char sigbuf[KEYBUF_SIZE];
    892894
    893895  SL_ENTER(_("sh_forward_try_impl"));
     
    10161018                        sh_tiger_hash((char *) &ticks,
    10171019                                      TIGER_DATA,
    1018                                       (unsigned long)sizeof(UINT32)),
     1020                                      (unsigned long)sizeof(UINT32),
     1021                                      hashbuf, sizeof(hashbuf)),
    10191022                        KEY_LEN+1);
    10201023
     
    10261029                        sh_tiger_hash(temp,
    10271030                                      TIGER_DATA,
    1028                                       (unsigned long)sl_strlen(temp)),
     1031                                      (unsigned long)sl_strlen(temp),
     1032                                      hashbuf, sizeof(hashbuf)),
    10291033                        KEY_LEN+1);
    10301034      sh_passwd (temp, NULL, NULL, foo_M1);
     
    11631167                  else /* if (0 != sh_srp_check_zero (answer)) */
    11641168                    {
    1165                       sl_strlcpy(u_real, sh_tiger_hash(head_u, TIGER_DATA, 4),
     1169                      sl_strlcpy(u_real, sh_tiger_hash(head_u, TIGER_DATA, 4,
     1170                                                       hashbuf, sizeof(hashbuf)),
    11661171                                 SH_CHALLENGE_SIZE);
    11671172                      foo_Sc = sh_srp_S_c (u_real, answer);
     
    11761181                      if (foo_Sc != NULL)
    11771182                        {
    1178                           sl_strlcpy(foo_M1,
    1179                                      sh_srp_M(foo_A,
    1180                                               answer,
    1181                                               sh_tiger_hash(foo_Sc,
    1182                                                             TIGER_DATA,
    1183                                                             sl_strlen(foo_Sc))),
    1184                                      KEY_LEN+1);
     1183                          sh_srp_M(foo_A,
     1184                                   answer,
     1185                                   sh_tiger_hash(foo_Sc,
     1186                                                 TIGER_DATA,
     1187                                                 sl_strlen(foo_Sc),
     1188                                                 hashbuf, sizeof(hashbuf)),
     1189                                   foo_M1, KEY_LEN+1);
     1190
    11851191
    11861192                          TPT(( 0, FIL__, __LINE__, _("msg=<srp:M1 = %s>\n"),
     
    12131219                          /* ------  verify M2 = H(A, M1, K) --------
    12141220                           */
     1221                          char M_buf[KEY_LEN+1];
    12151222                          M = sh_srp_M (foo_A, foo_M1,
    12161223                                        sh_tiger_hash(foo_Sc,
    12171224                                                      TIGER_DATA,
    1218                                                       sl_strlen(foo_Sc)));
     1225                                                      sl_strlen(foo_Sc),
     1226                                                      hashbuf, sizeof(hashbuf)),
     1227                                        M_buf, sizeof(M_buf)
     1228                                        );
    12191229                          if (M != NULL &&
    12201230                              0 == sl_strncmp (answer, M, KEY_LEN+1))
     
    12231233                                          sh_tiger_hash(foo_Sc,
    12241234                                                        TIGER_DATA,
    1225                                                         sl_strlen(foo_Sc)),
     1235                                                        sl_strlen(foo_Sc),
     1236                                                        hashbuf, sizeof(hashbuf)),
    12261237                                          KEY_LEN+1);
    12271238                              TPT(( 0, FIL__, __LINE__,
     
    13011312  (void) sl_strlcpy (answer, sh_util_siggen(skey->session,
    13021313                                            sh.host.name,
    1303                                             sl_strlen(sh.host.name)),
     1314                                            sl_strlen(sh.host.name),
     1315                                            sigbuf, sizeof(sigbuf)),
    13041316              KEY_LEN+1);
    13051317  TPT((0, FIL__, __LINE__, _("msg=<host %s>\n"), sh.host.name));
     
    13731385                                    sh_util_siggen (skey->session,
    13741386                                                    buffer,
    1375                                                     sl_strlen(buffer)),
     1387                                                    sl_strlen(buffer),
     1388                                                    sigbuf, sizeof(sigbuf)),
    13761389                                    KEY_LEN+1);
    13771390                  TPT((0, FIL__, __LINE__, _("msg=<sign %s.>\n"),
    13781391                       sh_util_siggen(skey->session, buffer,
    1379                                       sl_strlen(buffer))));                   
     1392                                      sl_strlen(buffer), sigbuf, sizeof(sigbuf))));                   
    13801393
    13811394                  (void) sl_strlcpy(buffer, errmsg, len);
     
    14391452                                            sh_util_siggen(skey->session,
    14401453                                                           buffer,
    1441                                                            sl_strlen(buffer)),
     1454                                                           sl_strlen(buffer),
     1455                                                           sigbuf, sizeof(sigbuf)),
    14421456                                            KEY_LEN);
    14431457                      TPT((0, FIL__, __LINE__, _("msg=<sign %s.>\n"),
    14441458                           sh_util_siggen(skey->session, buffer,
    1445                                           sl_strlen(buffer))));
     1459                                          sl_strlen(buffer), sigbuf, sizeof(sigbuf))));
    14461460
    14471461                      if (flag_err != 0)
     
    14731487                                           sh_util_siggen(skey->session,
    14741488                                                          buffer,
    1475                                                           pos),
     1489                                                          pos,
     1490                                                          sigbuf, sizeof(sigbuf)),
    14761491                                           KEY_LEN);
    14771492                             
     
    15831598                                sh_tiger_hash((char *) &ticks,
    15841599                                              TIGER_DATA,
    1585                                               (unsigned long)sizeof(UINT32)),
     1600                                              (unsigned long)sizeof(UINT32),
     1601                                              hashbuf, sizeof(hashbuf)),
    15861602                                KEY_LEN+1);
    15871603
     
    15921608              (void)sl_strlcpy(foo_M1,
    15931609                               sh_tiger_hash(buffer, TIGER_DATA,
    1594                                              (unsigned long)sl_strlen(buffer)),
     1610                                             (unsigned long)sl_strlen(buffer),
     1611                                             hashbuf, sizeof(hashbuf)),
    15951612                               KEY_LEN+1);
    15961613              memset (buffer, 0, sl_strlen(buffer));
     
    17731790  unsigned char   in[PW_LEN+1];
    17741791  int    i = 0, j, k, l = 0;
     1792  char hashbuf[KEYBUF_SIZE];
    17751793 
    17761794  if (sl_strlen(str) != (PW_LEN * 2))
     
    18001818
    18011819  sl_strlcpy ((char *)key,
    1802               sh_tiger_hash ((char*)in, TIGER_DATA, PW_LEN),
     1820              sh_tiger_hash ((char*)in, TIGER_DATA, PW_LEN,
     1821                             hashbuf, sizeof(hashbuf)),
    18031822              KEY_LEN+1);
    18041823  key[KEY_LEN] = '\0';
     
    18221841  char   in[PW_LEN];
    18231842  int    i = 0, j, k, l = 0;
     1843  char hashbuf[KEYBUF_SIZE];
    18241844 
    18251845  if (sl_strlen(str) != (PW_LEN*2))
     
    18511871      {
    18521872        sh_util_keyinit(key, KEY_LEN);
    1853         sl_strlcpy(salt, sh_tiger_hash(key, TIGER_DATA, KEY_LEN), 17);
     1873        sl_strlcpy(salt, sh_tiger_hash(key, TIGER_DATA, KEY_LEN,
     1874                                       hashbuf, sizeof(hashbuf)),
     1875                   17);
    18541876        sh_srp_x (salt, in);
    18551877        foo_v  = sh_srp_verifier ();
     
    18731895  UINT32   val[2];
    18741896  char     output[KEY_LEN+1];
     1897  char hashbuf[KEYBUF_SIZE];
    18751898
    18761899  val[0] = taus_get (&(skey->rng0[0]), &(skey->rng0[1]), &(skey->rng0[2]));
     
    18781901
    18791902  sl_strlcpy (output,
    1880               sh_tiger_hash((char *)(&val[0]), TIGER_DATA, 2*sizeof(UINT32)),
     1903              sh_tiger_hash((char *)(&val[0]), TIGER_DATA, 2*sizeof(UINT32),
     1904                            hashbuf, sizeof(hashbuf)),
    18811905              KEY_LEN);
    18821906
     
    28172841  char     * foo_Ss;
    28182842#endif
     2843  char hashbuf[KEYBUF_SIZE];
     2844  char sigbuf[KEYBUF_SIZE];
    28192845
    28202846  SL_ENTER(_("check_protocol"));
     
    29082934                          sh_util_siggen(this_client->session_key,
    29092935                                         &(conn->buf[KEY_LEN]),
    2910                                          sl_strlen(&(conn->buf[KEY_LEN]))),
     2936                                         sl_strlen(&(conn->buf[KEY_LEN])),
     2937                                         sigbuf, sizeof(sigbuf)),
    29112938                          KEY_LEN+1);
    29122939              TPT((0, FIL__, __LINE__, _("msg=<host %s>\n"),
     
    29172944                   sh_util_siggen(this_client->session_key,
    29182945                                  &(conn->buf[KEY_LEN]),
    2919                                   sl_strlen(&(conn->buf[KEY_LEN])))));
     2946                                  sl_strlen(&(conn->buf[KEY_LEN])),
     2947                                  sigbuf, sizeof(sigbuf))));
    29202948
    29212949              if (0 != sl_strncmp(conn->K, conn->buf, KEY_LEN))
     
    29532981              sl_strlcpy (conn->K,
    29542982                          sh_tiger_hash ((char *) &ticks,
    2955                                          TIGER_DATA, sizeof(UINT32)),
     2983                                         TIGER_DATA, sizeof(UINT32),
     2984                                         hashbuf, sizeof(hashbuf)),
    29562985                          KEY_LEN+1);
    29572986
     
    29853014              sl_strlcat(conn->A, conn->client_entry->session_key,
    29863015                         3*KEY_LEN+1);
    2987               sl_strlcpy (conn->K, sh_tiger_hash(conn->A,TIGER_DATA,3*KEY_LEN),
     3016              sl_strlcpy (conn->K, sh_tiger_hash(conn->A,TIGER_DATA,3*KEY_LEN,
     3017                                                 hashbuf, sizeof(hashbuf)),
    29883018                          KEY_LEN+1);
    29893019              SH_FREE(conn->A);
     
    33683398                          sh_util_siggen(this_client->session_key,
    33693399                                         &(conn->buf[KEY_LEN]),
    3370                                          sl_strlen(&(conn->buf[KEY_LEN]))),
     3400                                         sl_strlen(&(conn->buf[KEY_LEN])),
     3401                                         sigbuf, sizeof(sigbuf)),
    33713402                          KEY_LEN+1);
    33723403              TPT((0, FIL__, __LINE__, _("msg=<host %s>\n"),
     
    34843515                              sh_util_siggen(conn->client_entry->session_key,
    34853516                                             buffer,
    3486                                              sl_strlen(buffer)),
     3517                                             sl_strlen(buffer),
     3518                                             sigbuf, sizeof(sigbuf)),
    34873519                              KEY_LEN);
    34883520              TPT((0, FIL__, __LINE__, _("msg=<sign %s.>\n"),
    34893521                   sh_util_siggen(conn->client_entry->session_key,
    34903522                                  buffer,
    3491                                   sl_strlen(buffer))));
     3523                                  sl_strlen(buffer),
     3524                                  sigbuf, sizeof(sigbuf))));
    34923525
    34933526
     
    36013634                         sh_util_siggen ( conn->client_entry->session_key,
    36023635                                          buffer,
    3603                                           sl_strlen(buffer)),
     3636                                          sl_strlen(buffer),
     3637                                          sigbuf, sizeof(sigbuf)),
    36043638                         KEY_LEN+1);
    36053639             
     
    36153649                             sh_util_siggen ( conn->client_entry->session_key,
    36163650                                              &hash[KEY_LEN],
    3617                                               sl_strlen(&hash[KEY_LEN])),
     3651                                              sl_strlen(&hash[KEY_LEN]),
     3652                                              sigbuf, sizeof(sigbuf)),
    36183653                             SH_MAXMSGLEN+KEY_LEN+1);
    36193654                 
     
    36313666                   sh_util_siggen(conn->client_entry->session_key,
    36323667                                  buffer,
    3633                                   sl_strlen(buffer))));
     3668                                  sl_strlen(buffer),
     3669                                  sigbuf, sizeof(sigbuf))));
    36343670         
    36353671#ifdef SH_ENCRYPT
     
    37673803              sl_strlcpy(conn->A,
    37683804                         sh_tiger_hash((char *) &ticks,
    3769                                        TIGER_DATA, sizeof(UINT32)),
     3805                                       TIGER_DATA, sizeof(UINT32),
     3806                                       hashbuf, sizeof(hashbuf)),
    37703807                         KEY_LEN+1);
    37713808              u[0] = 'I'; u[1] = 'N'; u[2] = 'I'; u[3] = 'T'; u[4] = '\0';
     
    38493886              sl_strlcpy(hash, sh_tiger_hash (conn->M1,
    38503887                                              TIGER_DATA,
    3851                                               sl_strlen(conn->M1)), KEY_LEN+1);
     3888                                              sl_strlen(conn->M1),
     3889                                              hashbuf, sizeof(hashbuf)),
     3890                         KEY_LEN+1);
    38523891              sh_passwd (hash, conn->client_entry->verifier, NULL, conn->M1);
    38533892
     
    40844123                  u[4] = '\0';
    40854124                  sl_strlcpy(conn->challenge,
    4086                              sh_tiger_hash(u, TIGER_DATA, 4),
     4125                             sh_tiger_hash(u, TIGER_DATA, 4, hashbuf, sizeof(hashbuf)),
    40874126                             SH_CHALLENGE_SIZE);
    40884127
     
    41164155                  sl_strlcpy(conn->K,
    41174156                             sh_tiger_hash(foo_Ss, TIGER_DATA,
    4118                                            sl_strlen(foo_Ss)),
     4157                                           sl_strlen(foo_Ss),
     4158                                           hashbuf, sizeof(hashbuf)),
    41194159                             KEY_LEN+1);
    41204160
     
    41254165                    }
    41264166                  conn->M1 = SH_ALLOC(KEY_LEN+1);
    4127                   sl_strlcpy(conn->M1,
    4128                           sh_srp_M (conn->A, foo_B, conn->K),
    4129                           KEY_LEN+1);
     4167                  sh_srp_M (conn->A, foo_B, conn->K, conn->M1, KEY_LEN+1);
    41304168
    41314169                  TPT((0, FIL__, __LINE__, _("msg=<srp:Ss = %s>\n"), foo_Ss));
     
    41964234                   * send M2
    41974235                   */
     4236                  char M_buf[KEY_LEN+1];
    41984237                  sh_forward_prep_send (conn,
    4199                                         sh_srp_M (conn->A, conn->M1, conn->K),
     4238                                        sh_srp_M (conn->A, conn->M1, conn->K,
     4239                                                  M_buf, sizeof(M_buf)),
    42004240                                        KEY_LEN+1,
    42014241                                        _("PARP"),
  • trunk/src/sh_gpg.c

    r132 r133  
    128128  SL_ENTER(_("sh_gpg_checksum"));
    129129
    130   tiger_fd = checkfd;
    131130#if defined(WITH_PGP)
    132   test_gpg = sh_tiger_hash_gpg (DEFAULT_PGP_PATH, TIGER_FD, 0);
    133 #else
    134   test_gpg = sh_tiger_hash_gpg (DEFAULT_GPG_PATH, TIGER_FD, 0);
     131  test_gpg = sh_tiger_hash_gpg (DEFAULT_PGP_PATH, checkfd, 0);
     132#else
     133  test_gpg = sh_tiger_hash_gpg (DEFAULT_GPG_PATH, checkfd, 0);
    135134#endif
    136135 
  • trunk/src/sh_hash.c

    r132 r133  
    430430  file_type * theFile;
    431431  char * str;
     432  char hashbuf[KEYBUF_SIZE];
    432433
    433434  /* --------  find the entry for the file ----------------       */
     
    438439    p = hashsearch( sh_tiger_hash(fullpath,
    439440                                  TIGER_DATA,
    440                                   sl_strlen(fullpath))
     441                                  sl_strlen(fullpath),
     442                                  hashbuf, sizeof(hashbuf))
    441443                    );
    442444  if (p == NULL)
     
    11161118  SL_TICKET open_tmp (void);
    11171119#endif
     1120  char hashbuf[KEYBUF_SIZE];
    11181121
    11191122  SL_ENTER(_("sh_hash_init"));
     
    11441147      sl_rewind (fd);
    11451148
    1146       tiger_fd = fd;
    11471149      sl_strlcpy (sh.data.hash,
    11481150                  sh_tiger_hash (file_path('C', 'R'), /*irrelevant, TIGER_FD*/
    1149                                  TIGER_FD, 0),
     1151                                 fd, 0, hashbuf, sizeof(hashbuf)),
    11501152                  KEY_LEN+1);
    11511153      sl_rewind (fd);
     
    11731175              file_path('D', 'R')));
    11741176
    1175         tiger_fd = fd;
    11761177        if (0 != sl_strncmp(sh.data.hash,
    1177                             sh_tiger_hash (file_path('D', 'R'), TIGER_FD, 0),
     1178                            sh_tiger_hash (file_path('D', 'R'), fd, 0,
     1179                                           hashbuf, sizeof(hashbuf)),
    11781180                            KEY_LEN)
    11791181            && sh.flag.checkSum != SH_CHECK_INIT)
     
    15501552    else
    15511553      {
     1554        char hashbuf[KEYBUF_SIZE];
     1555
    15521556        sl_strlcpy(fullpath,
    15531557                   sh_tiger_hash (buf->fullpath,
    1554                                   TIGER_DATA, old_len),
     1558                                  TIGER_DATA, old_len,
     1559                                  hashbuf, sizeof(hashbuf)),
    15551560                   KEY_LEN+1);
    15561561      }
     
    15871592      else
    15881593        {
     1594          char hashbuf[KEYBUF_SIZE];
    15891595          sl_strlcpy(linkpath,
    15901596                     sh_tiger_hash (buf->linkpath,
    1591                                     TIGER_DATA, old_len),
     1597                                    TIGER_DATA, old_len,
     1598                                    hashbuf, sizeof(hashbuf)),
    15921599                     KEY_LEN+1);
    15931600        }
     
    18281835{
    18291836  sh_file_t * p;
     1837  char hashbuf[KEYBUF_SIZE];
    18301838
    18311839  SL_ENTER(_("sh_hash_have_it_int"));
     
    18391847    p = hashsearch(newname);
    18401848  else
    1841     p = hashsearch ( sh_tiger_hash(newname, TIGER_DATA, sl_strlen(newname)) );
     1849    p = hashsearch ( sh_tiger_hash(newname, TIGER_DATA, sl_strlen(newname),
     1850                                   hashbuf, sizeof(hashbuf)) );
    18421851  if (p == NULL)
    18431852     SL_RETURN( (NULL), _("sh_hash_have_it_int"));
     
    19191928{
    19201929  sh_file_t * p;
     1930  char hashbuf[KEYBUF_SIZE];
    19211931
    19221932  SL_ENTER(_("sh_hash_set_visited_int"));
     
    19301940    p = hashsearch(newname);
    19311941  else
    1932     p = hashsearch (sh_tiger_hash(newname, TIGER_DATA, sl_strlen(newname)));
     1942    p = hashsearch (sh_tiger_hash(newname, TIGER_DATA, sl_strlen(newname),
     1943                                  hashbuf, sizeof(hashbuf)));
    19331944 
    19341945  if (p == NULL)
     
    21202131  char * linkpath;
    21212132  char * attr_string = NULL;
     2133  char hashbuf[KEYBUF_SIZE];
    21222134
    21232135  SL_ENTER(_("sh_hash_push_int"));
     
    21702182      fullpath = SH_ALLOC(KEY_LEN + 1);
    21712183      sl_strlcpy(fullpath,
    2172                  sh_tiger_hash (buf->fullpath, TIGER_DATA, len),
     2184                 sh_tiger_hash (buf->fullpath, TIGER_DATA, len,
     2185                                hashbuf, sizeof(hashbuf)),
    21732186                 KEY_LEN+1);
    21742187    }
     
    21872200          linkpath = SH_ALLOC(KEY_LEN + 1);
    21882201          sl_strlcpy(linkpath,
    2189                      sh_tiger_hash (buf->linkpath, TIGER_DATA, len),
     2202                     sh_tiger_hash (buf->linkpath, TIGER_DATA, len,
     2203                                    hashbuf, sizeof(hashbuf)),
    21902204                     KEY_LEN+1);
    21912205        }
     
    26162630  char log_policy[32];
    26172631  int  log_severity;
     2632  char hashbuf[KEYBUF_SIZE];
    26182633
    26192634  SL_ENTER(_("sh_hash_compdata"));
     
    26362651    p = hashsearch( sh_tiger_hash(theFile->fullpath,
    26372652                                  TIGER_DATA,
    2638                                   sl_strlen(theFile->fullpath))
     2653                                  sl_strlen(theFile->fullpath),
     2654                                  hashbuf, sizeof(hashbuf))
    26392655                    );
    26402656
     
    27392755                     sh_tiger_hash(theFile->linkpath,
    27402756                                   TIGER_DATA,
    2741                                    sl_strlen(theFile->linkpath)),
     2757                                   sl_strlen(theFile->linkpath),
     2758                                   hashbuf, sizeof(hashbuf)),
    27422759                     MAX_PATH_STORE+1);
    27432760          maxcomp = MAX_PATH_STORE;
  • trunk/src/sh_mail.c

    r132 r133  
    223223      else
    224224        {
     225          char sigbuf[KEYBUF_SIZE];
     226
    225227          /* iterate key
    226228           */
     
    228230          for (i = 0; i < numsig; ++i)
    229231            {
     232              char hashbuf[KEYBUF_SIZE];
    230233              (void) sl_strlcpy (key2,
    231                                  sh_tiger_hash (key2, TIGER_DATA, KEY_LEN),
     234                                 sh_tiger_hash (key2, TIGER_DATA, KEY_LEN,
     235                                                hashbuf, sizeof(hashbuf)),
    232236                                 KEY_LEN+1);
    233237            }
    234238         
    235239
    236           theSig = sh_util_siggen (key2, bufc, sl_strlen(bufc));
     240          theSig = sh_util_siggen (key2, bufc, sl_strlen(bufc), sigbuf, sizeof(sigbuf));
    237241          if (sl_strncmp (key,
    238242                          theSig,
     
    811815    size_t    combufsize = SH_MAILBUF;
    812816    char      timebuf[81];
     817    char hashbuf[KEYBUF_SIZE];
    813818
    814819    SL_ENTER(_("sh_mail_msg"));
     
    10041009     */
    10051010    (void) sl_strlcpy(skey->mailkey_new,
    1006                       sh_tiger_hash (skey->mailkey_old, TIGER_DATA, KEY_LEN),
     1011                      sh_tiger_hash (skey->mailkey_old, TIGER_DATA, KEY_LEN,
     1012                                     hashbuf, sizeof(hashbuf)),
    10071013                      KEY_LEN+1);
    10081014
    10091015    if (isfirst == 0)
    10101016      {
     1017        char sigbuf[KEYBUF_SIZE];
     1018
    10111019        /* Sign the message with the signature key.
    10121020         */
    10131021        theSig = sh_util_siggen (skey->mailkey_new,
    1014                                  bufcompress, sl_strlen(bufcompress));
     1022                                 bufcompress, sl_strlen(bufcompress),
     1023                                 sigbuf, sizeof(sigbuf));
    10151024        (void) sl_strlcat (mailMsg,
    10161025                           theSig,
  • trunk/src/sh_prelink.c

    r132 r133  
    112112  SL_TICKET ticket;
    113113  char * tmp;
     114  char hashbuf[KEYBUF_SIZE];
    114115
    115116  if (task->com_ti != (-1))
     
    128129      return;
    129130    }
    130   tiger_fd = ticket;
     131
    131132  if (*(task->checksum) == '\0' ||
    132133      0 == sl_strcmp(task->checksum,
    133                      sh_tiger_hash (task->command, TIGER_FD, 0)))
     134                     sh_tiger_hash (task->command, ticket, 0, hashbuf, sizeof(hashbuf))))
    134135    {
    135136      task->com_fd = get_the_fd(ticket);
     
    256257  /* read from pipe
    257258   */
    258   tiger_fd = task.pipeTI;
    259 
    260259  sl_read_timeout_prep (task.pipeTI);
    261260
    262   sl_strlcpy(file_hash,
    263              sh_tiger_generic_hash (path, TIGER_FD, TIGER_NOLIM, alert_timeout),
    264              KEY_LEN+1);
     261  {
     262    char hashbuf[KEYBUF_SIZE];
     263    sl_strlcpy(file_hash,
     264               sh_tiger_generic_hash (path, task.pipeTI, TIGER_NOLIM, alert_timeout,
     265                                      hashbuf, sizeof(hashbuf)),
     266               KEY_LEN+1);
     267  }
    265268
    266269  /* restore old signal handler
  • trunk/src/sh_readconf.c

    r77 r133  
    191191#endif
    192192  uid_t  euid;
     193  char hashbuf[KEYBUF_SIZE];
    193194
    194195  SL_ENTER(_("sh_readconf_read"));
     
    251252  /* Compute the checksum of the open file.
    252253   */
    253   tiger_fd = fd;
    254254  sl_strlcpy(sh.conf.hash,
    255              sh_tiger_hash(file_path('C',local_flag),TIGER_FD, 0),
     255             sh_tiger_hash(file_path('C',local_flag), fd, 0, hashbuf, sizeof(hashbuf)),
    256256             KEY_LEN+1);
    257257  sl_rewind (fd);
  • trunk/src/sh_srp.c

    r34 r133  
    200200  register int i;
    201201  unsigned char * dez = NULL;
     202  char hashbuf[KEYBUF_SIZE];
    202203
    203204  SL_ENTER(_("sh_srp_x"));
     
    218219
    219220  (void) sl_strlcpy (skey->vernam,
    220                      sh_tiger_hash(skey->vernam, TIGER_DATA, PW_LEN), KEY_LEN);
     221                     sh_tiger_hash(skey->vernam, TIGER_DATA, PW_LEN,
     222                                   hashbuf, sizeof(hashbuf)),
     223                     KEY_LEN);
    221224  skey->vernam[KEY_LEN] = '\0';
    222225
     
    233236  (void) sl_strlcpy (sh_srp.x,
    234237                     sh_tiger_hash(combi, TIGER_DATA,
    235                                    (unsigned long) sl_strlen(combi)),
     238                                   (unsigned long) sl_strlen(combi),
     239                                   hashbuf, sizeof(hashbuf)),
    236240                     KEY_LEN+1);
    237241  SH_FREE (combi);
     
    240244}
    241245
    242 char * sh_srp_M (char * x1, char * x2, char * x3)
     246char * sh_srp_M (char * x1, char * x2, char * x3, char * hash, size_t size)
    243247{
    244248  char           *combi;
    245249  size_t          len, l2, l3;
    246   static char     hash[KEY_LEN+1];
    247250 
    248251  SL_ENTER(_("sh_srp_M"));
     
    266269  (void) sl_strlcat (combi, x2, len);
    267270  (void) sl_strlcat (combi, x3, len);
    268   (void) sl_strlcpy (hash,
    269                      sh_tiger_hash(combi, TIGER_DATA, (unsigned long) (len-1)),
    270                      KEY_LEN+1);
     271  (void) sh_tiger_hash(combi, TIGER_DATA, (unsigned long) (len-1),
     272                       hash, size);
    271273  SH_FREE (combi);
    272274 
  • trunk/src/sh_tiger0.c

    r131 r133  
    9999 * implementation
    100100 */
    101 SL_TICKET tiger_fd = (-1);
    102101
    103102static sh_byte buffer[PRIV_MAX + 72];
     
    106105static
    107106word64 * sh_tiger_hash_val (const char * filename, TigerType what,
    108                             UINT64 Length, int timeout)
     107                            UINT64 Length, int timeout, word64 * res)
    109108#else
    110109static
    111110sh_word32 * sh_tiger_hash_val (const char * filename, TigerType what,
    112                                UINT64 Length, int timeout)
     111                               UINT64 Length, int timeout, sh_word32 * res)
    113112#endif
    114113{
     
    138137#if defined(TIGER_64_BIT)
    139138#define TIGER_CAST (word64*)
    140   static word64 res[3];
     139  /* word64 res[3]; */
    141140  res[0]= (word64) 0x0123456789ABCDEFLL;
    142141  res[1]= (word64) 0xFEDCBA9876543210LL;
     
    144143#else
    145144#define TIGER_CAST (sh_word32*)
    146   static sh_word32 res[6];
     145  /* sh_word32 res[6]; */
    147146  res[0]= (sh_word32) 0x89ABCDEF;
    148147  res[1]= (sh_word32) 0x01234567;
     
    155154  SL_ENTER(_("sh_tiger_hash_val"));
    156155
    157   if (what == TIGER_FD || what == TIGER_FILE)
     156  if (what >= TIGER_FILE)
    158157    {
    159       if (what == TIGER_FD)
     158      if (what > TIGER_FD)
    160159        {
    161           fd = tiger_fd;
    162           TPT((0,FIL__, __LINE__, _("msg=<TIGER_FD>, fd=<%ld>\n"), tiger_fd));
     160          fd = what;
     161          TPT((0,FIL__, __LINE__, _("msg=<TIGER_FD>, fd=<%ld>\n"), fd));
    163162        }
    164163      else
     
    171170      if (SL_ISERROR (fd))
    172171        {
    173           TPT((0, FIL__, __LINE__, _("msg=<SL_ISERROR (%ld)>\n"), tiger_fd));
     172          TPT((0, FIL__, __LINE__, _("msg=<SL_ISERROR (%ld)>\n"), fd));
    174173          tmp = sh_util_safe_name (filename);
    175174          (void) sl_get_euid(&euid);
     
    179178          SL_RETURN( NULL, _("sh_tiger_hash_val"));
    180179        }
    181      
     180
     181      SH_MUTEX_LOCK(mutex_skey); 
    182182#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
    183183    if ((lockflag == SL_FALSE) && (skey->mlock_failed == SL_FALSE))
     
    196196      }
    197197#endif
     198    SH_MUTEX_UNLOCK(mutex_skey);
    198199
    199200#ifdef TIGER_DBG
     
    254255
    255256        nblocks += blk;
     257        /* MAY_LOCK */
    256258        sh.statistics.bytes_hashed += tt;
    257259       
     
    331333          bbuf[j++] = (sh_byte) 0;
    332334        tiger_t(TIGER_CAST bbuf, 64, res);
     335        /* MAY_LOCK */
    333336        sh.statistics.bytes_hashed += 64;
    334337        ++nblocks; ncount = 0;
     
    361364    if (what == TIGER_FILE)
    362365      (void) sl_close (fd);
    363     else
    364       tiger_fd = (-1);
    365366
    366367    SL_RETURN( res, _("sh_tiger_hash_val"));
     
    807808   beginning at RESBLOCK.  */
    808809static int md5_stream(char * filename, void *resblock,
    809                       UINT64 Length, int timeout)
     810                      UINT64 Length, int timeout, SL_TICKET fd)
    810811{
    811812  /* Important: BLOCKSIZE must be a multiple of 64.  */
     
    830831  (void) md5Reset (&ctx);
    831832
    832   fd = tiger_fd;
    833 
    834833  if (SL_ISERROR (fd))
    835834    {
    836       TPT((0, FIL__, __LINE__, _("msg=<SL_ISERROR (%ld)>\n"), tiger_fd));
     835      TPT((0, FIL__, __LINE__, _("msg=<SL_ISERROR (%ld)>\n"), fd));
    837836      tmp = sh_util_safe_name (filename);
    838837      (void) sl_get_euid(&euid);
     
    932931static
    933932char * sh_tiger_md5_hash  (char * filename, TigerType what,
    934                            UINT64 Length, int timeout)
     933                           UINT64 Length, int timeout, char * out, size_t len)
    935934{
    936935  int cnt;
    937   static char out[KEY_LEN+1];
     936  char outbuf[KEY_LEN+1];
    938937  unsigned char md5buffer[16];
    939938
    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);
     939  (void) md5_stream (filename, md5buffer, Length, timeout, what);
    950940
    951941  /*@-bufferoverflowhigh -usedef@*/
    952942  for (cnt = 0; cnt < 16; ++cnt)
    953     sprintf (&out[cnt*2], _("%02X"),                 /* known to fit  */
     943    sprintf (&outbuf[cnt*2], _("%02X"),                 /* known to fit  */
    954944             (unsigned int) md5buffer[cnt]);
    955945  /*@+bufferoverflowhigh +usedef@*/
    956946  for (cnt = 32; cnt < KEY_LEN; ++cnt)
    957     out[cnt] = '0';
    958   out[KEY_LEN] = '\0';
    959 
     947    outbuf[cnt] = '0';
     948  outbuf[KEY_LEN] = '\0';
     949
     950  sl_strlcpy(out, outbuf, len);
    960951  return out;
    961952}
     
    13281319   beginning at RESBLOCK.  */
    13291320static int sha1_stream(char * filename, void *resblock,
    1330                        UINT64 Length, int timeout)
     1321                       UINT64 Length, int timeout, SL_TICKET fd)
    13311322{
    13321323  /* Important: BLOCKSIZE must be a multiple of 64.  */
     
    13501341  (void) sha_init(&ctx);
    13511342
    1352   fd = tiger_fd;
    1353 
    13541343  if (SL_ISERROR (fd))
    13551344    {
    1356       TPT((0, FIL__, __LINE__, _("msg=<SL_ISERROR (%ld)>\n"), tiger_fd));
     1345      TPT((0, FIL__, __LINE__, _("msg=<SL_ISERROR (%ld)>\n"), fd));
    13571346      tmp = sh_util_safe_name (filename);
    13581347      (void) sl_get_euid(&euid);
     
    14571446
    14581447static char * sh_tiger_sha1_hash  (char * filename, TigerType what,
    1459                                    UINT64 Length, int timeout)
     1448                                   UINT64 Length, int timeout,
     1449                                   char * out, size_t len)
    14601450{
    14611451  int cnt = (int) Length;  /* fix compiler warning */
    1462   static char out[KEY_LEN+1];
     1452  char outbuf[KEY_LEN+1];
    14631453  unsigned char sha1buffer[20];
    14641454
    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);
     1455  (void) sha1_stream (filename, sha1buffer, Length, timeout, what);
    14751456
    14761457  /*@-bufferoverflowhigh -usedef@*/
    14771458  for (cnt = 0; cnt < 20; ++cnt)
    1478     sprintf (&out[cnt*2], _("%02X"),                 /* known to fit  */
     1459    sprintf (&outbuf[cnt*2], _("%02X"),              /* known to fit  */
    14791460             (unsigned int) sha1buffer[cnt]);
    14801461  /*@+bufferoverflowhigh +usedef@*/
    14811462  for (cnt = 40; cnt < KEY_LEN; ++cnt)
    1482     out[cnt] = '0';
    1483   out[KEY_LEN] = '\0';
    1484 
     1463    outbuf[cnt] = '0';
     1464  outbuf[KEY_LEN] = '\0';
     1465
     1466  sl_strlcpy(out, outbuf, len);
    14851467  return out;
    14861468}
     
    15231505
    15241506static char * sh_tiger_hash_internal (const char * filename, TigerType what,
    1525                                       UINT64 Length, int timeout);
     1507                                      UINT64 Length, int timeout,
     1508                                      char * out, size_t len);
    15261509
    15271510char * sh_tiger_hash (const char * filename, TigerType what,
    1528                       UINT64 Length)
    1529 {
    1530   return sh_tiger_hash_internal (filename, what, Length, 0);
     1511                      UINT64 Length, char * out, size_t len)
     1512{
     1513  return sh_tiger_hash_internal (filename, what, Length, 0, out,len);
    15311514}
    15321515
    15331516char * sh_tiger_generic_hash (char * filename, TigerType what,
    1534                               UINT64 Length, int timeout)
     1517                              UINT64 Length, int timeout,
     1518                              char * out, size_t len)
    15351519{
    15361520#ifdef USE_SHA1
    15371521  if (hash_type == 1)
    1538     return sh_tiger_sha1_hash    (filename, what, Length, timeout);
     1522    return sh_tiger_sha1_hash    (filename, what, Length, timeout, out, len);
    15391523#endif
    15401524#ifdef USE_MD5
    15411525  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);
     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);
    15451529}
    15461530
     
    15491533 
    15501534static char * sh_tiger_hash_internal (const char * filename, TigerType what,
    1551                                       UINT64 Length, int timeout)
     1535                                      UINT64 Length, int timeout,
     1536                                      char * out, size_t len)
    15521537{
    15531538#if defined(TIGER_64_BIT)
    1554   word64 * res;
     1539  word64 res[3];
    15551540#else
    1556   sh_word32 * res;
    1557 #endif
    1558   static char out[KEY_LEN+1];
     1541  sh_word32 res[6];
     1542#endif
    15591543
    15601544  SL_ENTER( _("sh_tiger_hash_internal"));
    15611545
    1562   res = sh_tiger_hash_val (filename, what, Length, timeout);
    1563 
    1564   if (res != NULL)
     1546  SH_VALIDATE_GE(len, (KEY_LEN+1));
     1547
     1548  if (NULL != sh_tiger_hash_val (filename, what, Length, timeout, res))
    15651549    {
    15661550#if defined(TIGER_64_BIT)
    1567       sl_snprintf(out,
    1568                   sizeof(out),
     1551      sl_snprintf(out, len,
    15691552                  MYFORMAT,
    15701553                  (sh_word32)(res[0]>>32),
     
    15751558                  (sh_word32)(res[2]) );
    15761559#else
    1577       sl_snprintf(out,
    1578                   sizeof(out),
     1560      sl_snprintf(out, len,
    15791561                  MYFORMAT,
    15801562                  (sh_word32)(res[1]),
     
    15851567                  (sh_word32)(res[4]) );
    15861568#endif
    1587       out[sizeof(out)-1] = '\0';
     1569      out[len-1] = '\0';
    15881570      SL_RETURN( out, _("sh_tiger_hash_internal"));
    15891571
     
    16001582  char   outhash[48+6+1];
    16011583#if defined(TIGER_64_BIT)
    1602   word64 * res;
     1584  word64 res[3];
    16031585#else
    1604   sh_word32 * res;
     1586  sh_word32 res[6];
    16051587#endif
    16061588
    16071589  SL_ENTER(_("sh_tiger_hash_gpg"));
    16081590
    1609   res = sh_tiger_hash_val (filename, what, Length, 0);
    1610   if (res != NULL)
     1591  if (NULL != sh_tiger_hash_val (filename, what, Length, 0, res))
    16111592    {
    16121593#if defined(TIGER_64_BIT)
     
    16631644UINT32 * sh_tiger_hash_uint32 (char * filename,
    16641645                               TigerType what,
    1665                                UINT64 Length)
     1646                               UINT64 Length, UINT32 * out, size_t len)
    16661647{
    16671648#if defined(TIGER_64_BIT)
    1668   word64 * res;
     1649  word64 res[3];
    16691650#else
    1670   sh_word32 * res;
    1671 #endif
    1672 
    1673   static UINT32 out[6];
     1651  sh_word32 res[6];
     1652#endif
    16741653
    16751654  SL_ENTER(_("sh_tiger_hash_uint32"));
     1655
     1656  SH_VALIDATE_GE(len, 6);
    16761657
    16771658  out[0] = 0; out[1] = 0; out[2] = 0;
    16781659  out[3] = 0; out[4] = 0; out[5] = 0;
    16791660
    1680   res = sh_tiger_hash_val (filename,  what,  Length, 0);
    1681 
    1682   if (res != NULL)
     1661  if (NULL != sh_tiger_hash_val (filename,  what,  Length, 0, res))
    16831662    {
    16841663#if defined(TIGER_64_BIT)
  • trunk/src/sh_tools.c

    r132 r133  
    13441344{
    13451345  char         * theSig;
     1346  char sigbuf[KEYBUF_SIZE];
    13461347
    13471348  SL_ENTER(_("sh_tools_hash_add"));
    13481349
    1349   theSig = sh_util_siggen (key, buf, buflen);
     1350  theSig = sh_util_siggen (key, buf, buflen, sigbuf, sizeof(sigbuf));
    13501351  sl_strlcat(buf, theSig, buflen + KEY_LEN + 1);
    13511352     
     
    13611362  register int   i;
    13621363  char         * theSig;
     1364  char sigbuf[KEYBUF_SIZE];
    13631365
    13641366  SL_ENTER(_("sh_tools_hash_vfy"));
    13651367
    1366   theSig = sh_util_siggen (key, buf, buflen);
     1368  theSig = sh_util_siggen (key, buf, buflen, sigbuf, sizeof(sigbuf));
    13671369  sl_strlcpy(hash, theSig, KEY_LEN+1);
    13681370
     
    13891391  int            total = 0;
    13901392  char         * theSig;
     1393  char sigbuf[KEYBUF_SIZE];
    13911394
    13921395
     
    14021405  ASSERT_RET((buflen >= 0), _("buflen >= 0"), (NULL));
    14031406
    1404   theSig = sh_util_siggen (key, buf, buflen);
     1407  theSig = sh_util_siggen (key, buf, buflen, sigbuf, sizeof(sigbuf));
    14051408  sl_strlcpy(hash, theSig, KEY_LEN+1);
    14061409
     
    14371440  register int   i;
    14381441  char         * theSig;
     1442  char sigbuf[KEYBUF_SIZE];
    14391443
    14401444  SL_ENTER(_("hash_check"));
     
    14441448          (key == NULL) ? "NULL" : key, buflen);
    14451449#endif
    1446   theSig = sh_util_siggen (key, &buf[KEY_LEN], buflen-KEY_LEN);
     1450  theSig = sh_util_siggen (key, &buf[KEY_LEN], buflen-KEY_LEN,
     1451                           sigbuf, sizeof(sigbuf));
    14471452  sl_strlcpy(hash, theSig, KEY_LEN+1);
    14481453     
     
    15971602  int           status = BAD;
    15981603  char        * my_tmp_dir;
     1604  char hashbuf[KEYBUF_SIZE];
    15991605
    16001606  SL_ENTER(_("open_tmp"));
     
    16291635    if (my_tmp_dir[0] == '/' && my_tmp_dir[1] == '\0')
    16301636      file = sh_util_strconcat (my_tmp_dir,
    1631                                 sh_tiger_hash( (char *) &ticks, TIGER_DATA, 4),
     1637                                sh_tiger_hash( (char *) &ticks, TIGER_DATA, 4,
     1638                                               hashbuf, sizeof(hashbuf)),
    16321639                                NULL);
    16331640    else
    16341641      file = sh_util_strconcat (my_tmp_dir,
    16351642                                "/",
    1636                                 sh_tiger_hash( (char *) &ticks, TIGER_DATA, 4),
     1643                                sh_tiger_hash( (char *) &ticks, TIGER_DATA, 4,
     1644                                               hashbuf, sizeof(hashbuf)),
    16371645                                NULL);
    16381646
  • trunk/src/sh_unix.c

    r132 r133  
    883883{
    884884  char message[512];
     885  char hashbuf[KEYBUF_SIZE];
    885886
    886887  SL_ENTER(_("sh_unix_self_hash"));
     
    894895
    895896  sl_strlcpy(sh.exec.hash,
    896              sh_tiger_hash (c, TIGER_FILE, 0),
     897             sh_tiger_hash (c, TIGER_FILE, 0, hashbuf, sizeof(hashbuf)),
    897898             KEY_LEN+1);
    898899  sl_snprintf(message, 512, _("%s has checksum: %s"),
     
    917918  char newhash[KEY_LEN+1];
    918919  char message[512];
     920  char hashbuf[KEYBUF_SIZE];
    919921
    920922  SL_ENTER(_("sh_unix_self_check"));
     
    922924    SL_RETURN((0), _("sh_unix_self_check"));
    923925
    924   sl_strlcpy(newhash, sh_tiger_hash (sh.exec.path, TIGER_FILE, 0), KEY_LEN+1);
     926  sl_strlcpy(newhash,
     927             sh_tiger_hash (sh.exec.path, TIGER_FILE, 0, hashbuf, sizeof(hashbuf)),
     928             KEY_LEN+1);
    925929  if (0 == sl_strncmp(sh.exec.hash,
    926930                      newhash,
     
    23572361}
    23582362
    2359 SH_MUTEX_STATIC(getUIDname, PTHREAD_MUTEX_INITIALIZER);
     2363SH_MUTEX_STATIC(mutex_getUIDname, PTHREAD_MUTEX_INITIALIZER);
    23602364
    23612365char *  sh_unix_getUIDname (int level, uid_t uid, char * out, size_t len)
     
    23752379  if ((uid == old_uid) && (name[0] != '\0')) {
    23762380    out[0] = '\0';
    2377     SH_MUTEX_LOCK_UNSAFE(getUIDname);
     2381    SH_MUTEX_LOCK_UNSAFE(mutex_getUIDname);
    23782382    if ((uid == old_uid) && (name[0] != '\0')) {
    23792383      sl_strlcpy(out, name, len);
    23802384    }
    2381     SH_MUTEX_UNLOCK_UNSAFE(getUIDname);
     2385    SH_MUTEX_UNLOCK_UNSAFE(mutex_getUIDname);
    23822386    if (out[0] != '\0')
    23832387      SL_RETURN( out, _("sh_unix_getUIDname"));
     
    24012405
    24022406  if (tempres->pw_name != NULL) {
    2403     SH_MUTEX_LOCK_UNSAFE(getUIDname);
     2407    SH_MUTEX_LOCK_UNSAFE(mutex_getUIDname);
    24042408    sl_strlcpy(name, tempres->pw_name, sizeof(name));
    24052409    old_uid = uid;
    24062410    sl_strlcpy(out, name, len);
    2407     SH_MUTEX_UNLOCK_UNSAFE(getUIDname);
     2411    SH_MUTEX_UNLOCK_UNSAFE(mutex_getUIDname);
    24082412    SL_RETURN( out, _("sh_unix_getUIDname"));
    24092413  } else {
     
    24152419}
    24162420
    2417 SH_MUTEX_STATIC(getGIDname, PTHREAD_MUTEX_INITIALIZER);
     2421SH_MUTEX_STATIC(mutex_getGIDname, PTHREAD_MUTEX_INITIALIZER);
    24182422
    24192423char *  sh_unix_getGIDname (int level, gid_t gid, char * out, size_t len)
     
    24342438  if ((gid == old_gid) && (name[0] != '\0')) {
    24352439    out[0] = '\0';
    2436     SH_MUTEX_LOCK_UNSAFE(getGIDname);
     2440    SH_MUTEX_LOCK_UNSAFE(mutex_getGIDname);
    24372441    if ((gid == old_gid) && (name[0] != '\0')) {
    24382442      sl_strlcpy(out, name, len);
    24392443    }
    2440     SH_MUTEX_UNLOCK_UNSAFE(getGIDname);
     2444    SH_MUTEX_UNLOCK_UNSAFE(mutex_getGIDname);
    24412445    if (out[0] != '\0')
    24422446      SL_RETURN( out, _("sh_unix_getGIDname"));
     
    24592463  }
    24602464
    2461   /* FIXME: need to return caller-supplied buffer */
    24622465  if (tempres->gr_name != NULL) {
    2463     SH_MUTEX_LOCK_UNSAFE(getGIDname);
     2466    SH_MUTEX_LOCK_UNSAFE(mutex_getGIDname);
    24642467    sl_strlcpy(name, tempres->gr_name, sizeof(name));
    24652468    old_gid = gid;
    24662469    sl_strlcpy(out, name, len);
    2467     SH_MUTEX_UNLOCK_UNSAFE(getGIDname);
     2470    SH_MUTEX_UNLOCK_UNSAFE(mutex_getGIDname);
    24682471    SL_RETURN( out, _("sh_unix_getGIDname"));
    24692472  } else {
     
    29932996
    29942997int sh_unix_checksum_size (char * filename, struct stat * fbuf,
    2995                            char * fileHash, int alert_timeout)
     2998                           char * fileHash, int alert_timeout, SL_TICKET fd)
    29962999{
    29973000  file_type tmpFile;
     
    30163019  if (tmpFile.size < fbuf->st_size)
    30173020    {
     3021      char hashbuf[KEYBUF_SIZE];
    30183022      sl_strlcpy(fileHash,
    3019                  sh_tiger_generic_hash (filename, TIGER_FD, tmpFile.size,
    3020                                         alert_timeout),
     3023                 sh_tiger_generic_hash (filename, fd, tmpFile.size,
     3024                                        alert_timeout, hashbuf, sizeof(hashbuf)),
    30213025                 KEY_LEN+1);
    30223026     
     
    33553359          else
    33563360            {
    3357               tiger_fd = rval_open;
     3361              char hashbuf[KEYBUF_SIZE];
    33583362              sl_strlcpy(fileHash,
    33593363                         sh_tiger_generic_hash (theFile->fullpath,
    3360                                                 TIGER_FD, TIGER_NOLIM,
    3361                                                 alert_timeout),
     3364                                                rval_open, TIGER_NOLIM,
     3365                                                alert_timeout,
     3366                                                hashbuf, sizeof(hashbuf)),
    33623367                         KEY_LEN+1);
    33633368              if ((theFile->check_mask & MODI_SGROW) != 0)
    33643369                {
    33653370                  sl_rewind(rval_open);
    3366                   tiger_fd = rval_open;
    33673371                  sh_unix_checksum_size (theFile->fullpath, &fbuf,
    33683372                                         &fileHash[KEY_LEN + 1],
    3369                                          alert_timeout);
     3373                                         alert_timeout, rval_open);
    33703374                }
    33713375            }
     
    33953399          else
    33963400            {
    3397               tiger_fd = rval_open;
     3401              char hashbuf[KEYBUF_SIZE];
    33983402              sl_strlcpy(fileHash,
    3399                          sh_tiger_generic_hash (theFile->fullpath, TIGER_FD, TIGER_NOLIM,
    3400                                                 alert_timeout),
     3403                         sh_tiger_generic_hash (theFile->fullpath, rval_open,
     3404                                                TIGER_NOLIM,
     3405                                                alert_timeout,
     3406                                                hashbuf, sizeof(hashbuf)),
    34013407                         KEY_LEN + 1);
    34023408              if ((theFile->check_mask & MODI_SGROW) != 0)
    34033409                {
    34043410                  sl_rewind(rval_open);
    3405                   tiger_fd = rval_open;
    34063411                  sh_unix_checksum_size (theFile->fullpath, &fbuf,
    34073412                                         &fileHash[KEY_LEN + 1],
    3408                                          alert_timeout);
     3413                                         alert_timeout, rval_open);
    34093414                }
    34103415            }
  • trunk/src/sh_utils.c

    r93 r133  
    642642 */
    643643static char * sh_util_hmac_tiger (char * hexkey, 
    644                                   char * text, size_t textlen)
     644                                  char * text, size_t textlen,
     645                                  char * res, size_t len)
    645646{
    646647  static char opad[KEY_BLOCK] = {
     
    669670  UINT32      cc[KEY_LEN/4];
    670671  char      * res;
     672  UINT32      kbuf[KEY_BYT/sizeof(UINT32)];
     673  char hashbuf[KEYBUF_SIZE];
     674
    671675
    672676  size_t      i;
     
    677681  if (KEY_BLOCK > (KEY_LEN/2))
    678682    {
    679       res = sh_tiger_hash (NULL, TIGER_DATA, 0);
     683      res = sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
    680684      SL_RETURN(res, _("sh_util_hmac_tiger"));
    681685    }
     
    685689  if (sh_util_hextobinary (K, hexkey, KEY_LEN) < 0)
    686690    {
    687       res = sh_tiger_hash (NULL, TIGER_DATA, 0);
     691      res = sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
    688692      SL_RETURN(res, _("sh_util_hmac_tiger"));
    689693    }
     
    708712                      _("integer overflow"),
    709713                      _("sh_util_hmac_tiger"));
    710       res = sh_tiger_hash (NULL, TIGER_DATA, 0);
     714      res = sh_tiger_hash (NULL, TIGER_DATA, 0, hashbuf, sizeof(hashbuf));
    711715      SL_RETURN(res, _("sh_util_hmac_tiger"));
    712716    }
     
    716720  h1 = sh_tiger_hash_uint32 ( outer,
    717721                              TIGER_DATA,
    718                               KEY_BLOCK);
     722                              KEY_BLOCK,
     723                              kbuf, KEY_BYT/sizeof(UINT32));
    719724  for (i = 0; i < (KEY_LEN/8); ++i)
    720725    {
     
    725730  h2 = sh_tiger_hash_uint32 ( inner,
    726731                              TIGER_DATA,
    727                               (unsigned long) KEY_BLOCK+textlen);
     732                              (unsigned long) KEY_BLOCK+textlen,
     733                              kbuf, KEY_BYT/sizeof(UINT32));
    728734  for (i = KEY_LEN/8; i < (KEY_LEN/4); ++i)
    729735    {
     
    733739  SH_FREE(inner);
    734740 
    735   res = sh_tiger_hash ((char *) &cc[0],
    736                        TIGER_DATA,
    737                        (unsigned long) (KEY_LEN/4 * sizeof(UINT32)));
    738 
     741  (void) sh_tiger_hash ((char *) &cc[0],
     742                        TIGER_DATA,
     743                        (unsigned long) (KEY_LEN/4 * sizeof(UINT32)),
     744                        hashbuf, sizeof(hashbuf));
     745
     746  sl_strlcpy(res, hashbuf, len);
    739747  SL_RETURN(res, _("sh_util_hmac_tiger"));
    740748}
    741749
    742750static char * sh_util_hash_tiger ( char * hexkey, 
    743                                    char * text, size_t textlen)
    744 {
    745   char         * res;
     751                                   char * text, size_t textlen
     752                                   char * res, size_t len)
     753{
    746754  char           h2[2*KEY_LEN+1];
    747755  SL_ENTER(_("sh_util_hash_tiger"));
    748756
    749757  (void) sl_strlcpy(h2, hexkey, KEY_LEN+1);
    750   (void) sl_strlcat(h2, sh_tiger_hash(text, TIGER_DATA,
    751                                       (unsigned long) textlen), 2*KEY_LEN+1);
    752 
    753   res = sh_tiger_hash(h2, TIGER_DATA, 2*KEY_LEN);
    754 
     758  (void) sl_strlcat(h2,
     759                    sh_tiger_hash(text, TIGER_DATA,
     760                                  (unsigned long) textlen,
     761                                  hashbuf, sizeof(hashbuf)),
     762                    2*KEY_LEN+1,
     763                    );
     764
     765  (void) sh_tiger_hash(h2, TIGER_DATA, 2*KEY_LEN, hashbuf, sizeof(hashbuf));
     766
     767  sl_strlcpy(res, hashbuf, len);
    755768  SL_RETURN(res, _("sh_util_hash_tiger"));
    756769}
     
    780793
    781794char * sh_util_siggen (char * hexkey, 
    782                        char * text, size_t textlen) 
     795                       char * text, size_t textlen,
     796                       char * res, size_t len) 
    783797{
    784798  char * p;
     
    787801  if (sigtype == TYPE_HMAC)
    788802    p = sh_util_hmac_tiger (hexkey, 
    789                             text, textlen);
     803                            text, textlen, res, len);
    790804  else
    791805    p = sh_util_hash_tiger (hexkey, 
    792                             text, textlen);
     806                            text, textlen, res, len);
    793807  SL_RETURN(p, _("sh_util_siggen"));
    794808}   
     
    927941  static   int      res_num = 0;
    928942  register int i;
     943  UINT32       kbuf[KEY_BYT/sizeof(UINT32)];
    929944
    930945  if (res_num > 0)
     
    944959  res     = sh_tiger_hash_uint32 ( (char *) &taus_svec[0],
    945960                                   TIGER_DATA,
    946                                    (unsigned long)(6 * sizeof(UINT32)));
     961                                   (unsigned long)(6 * sizeof(UINT32)),
     962                                   kbuf, KEY_BYT/sizeof(UINT32));
    947963
    948964  for (i = 1; i < 6; ++i)
     
    11801196          image[k+7] == new_key[7])
    11811197        {
     1198          UINT32 kbuf[KEY_BYT/sizeof(UINT32)];
     1199
    11821200          printf(_("old key found\n"));
    11831201          h1 = sh_tiger_hash_uint32 (key, TIGER_DATA,
    1184                                      (unsigned long)strlen(key));
     1202                                     (unsigned long)strlen(key),
     1203                                     kbuf, KEY_BYT/sizeof(UINT32));
    11851204          copy_four( (unsigned char *) &(image[k]),   h1[0]);
    11861205          copy_four( (unsigned char *) &(image[k+4]), h1[1]);
     
    12291248  register int    i, j, j1 = 0, j2 = 0, j3;
    12301249  char          * dez;
     1250  char hashbuf[KEYBUF_SIZE];
    12311251
    12321252  SL_ENTER(_("sh_util_encode"));
     
    12481268
    12491269  (void) sl_strlcpy(skey->vernam,
    1250                     sh_tiger_hash(skey->vernam, TIGER_DATA, KEY_LEN),
     1270                    sh_tiger_hash(skey->vernam, TIGER_DATA, KEY_LEN,
     1271                                  hashbuf, sizeof(hashbuf)),
    12511272                    KEY_LEN+1);
    12521273
    12531274  (void) sl_strlcpy(skey->vernam,
    1254                     sh_util_hmac_tiger (skey->vernam, salt, strlen(salt)),
    1255              KEY_LEN+1);
     1275                    sh_util_hmac_tiger (skey->vernam, salt, strlen(salt),
     1276                                        hashbuf, sizeof(hashbuf)),
     1277                    KEY_LEN+1);
    12561278
    12571279  (void) sl_strlcpy(skey->vernam,
    1258                     sh_util_hmac_tiger (skey->vernam, (char*) new_key, 8),
     1280                    sh_util_hmac_tiger (skey->vernam, (char*) new_key, 8,
     1281                                        hashbuf, sizeof(hashbuf)),
    12591282                    KEY_LEN+1);
    12601283
     
    14131436  int          status = 0;
    14141437  char       * p;
     1438  char hashbuf[KEYBUF_SIZE];
    14151439
    14161440  SL_ENTER(_("sh_util_keyinit"));
     
    14331457
    14341458  p = sh_tiger_hash ((char *) bufy, TIGER_DATA,
    1435                      (unsigned long)(6*sizeof(UINT32)));
    1436   p[size-1] = '\0';
     1459                     (unsigned long)(6*sizeof(UINT32)),
     1460                     hashbuf, sizeof(hashbuf));
    14371461
    14381462  i = sl_strlcpy(buf, p, (size_t)size);
Note: See TracChangeset for help on using the changeset viewer.