Changeset 133


Ignore:
Timestamp:
Oct 25, 2007, 12:19:05 AM (11 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.