Changeset 133 for trunk/src/sh_utils.c


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

Reentrant checksum/hash functions.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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.