bnethash.c
上传用户:tany51
上传日期:2013-06-12
资源大小:1397k
文件大小:5k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*
  2.  * Copyright (C) 1999  Descolada (dyn1-tnt9-237.chicago.il.ameritech.net)
  3.  * Copyright (C) 1999,2000  Ross Combs (rocombs@cs.nmsu.edu)
  4.  *
  5.  * This program is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU General Public License
  7.  * as published by the Free Software Foundation; either version 2
  8.  * of the License, or (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  */
  19. #include "common/setup_before.h"
  20. #include <stdio.h>
  21. #ifdef HAVE_STDDEF_H
  22. # include <stddef.h>
  23. #else
  24. # ifndef NULL
  25. #  define NULL ((void *)0)
  26. # endif
  27. #endif
  28. #ifdef STDC_HEADERS
  29. # include <stdlib.h>
  30. #endif
  31. #ifdef HAVE_STRING_H
  32. # include <string.h>
  33. #else
  34. # ifdef HAVE_STRINGS_H
  35. #  include <strings.h>
  36. # endif
  37. #endif
  38. #include "compat/uint.h"
  39. #include "common/introtate.h"
  40. #include "common/eventlog.h"
  41. #include "common/bnethash.h"
  42. #include "common/setup_after.h"
  43. static void hash_init(t_hash * hash);
  44. static void do_hash(t_hash * hash, t_uint32 * tmp);
  45. static void hash_set_16(t_uint32 * dst, unsigned char const * src, unsigned int count);
  46. static void hash_init(t_hash * hash)
  47. {
  48.     (*hash)[0] = 0x67452301;
  49.     (*hash)[1] = 0xefcdab89;
  50.     (*hash)[2] = 0x98badcfe;
  51.     (*hash)[3] = 0x10325476;
  52.     (*hash)[4] = 0xc3d2e1f0;
  53. }
  54. static void do_hash(t_hash * hash, t_uint32 * tmp)
  55. {
  56.     unsigned int i;
  57.     t_uint32     a,b,c,d,e,g;
  58.     
  59.     for (i=0; i<64; i++)
  60. tmp[i+16] = ROTL32(1,tmp[i] ^ tmp[i+8] ^ tmp[i+2] ^ tmp[i+13]);
  61.     
  62.     a = (*hash)[0];
  63.     b = (*hash)[1];
  64.     c = (*hash)[2];
  65.     d = (*hash)[3];
  66.     e = (*hash)[4];
  67.     
  68.     for (i=0; i<20*1; i++)
  69.     {
  70. g = tmp[i] + ROTL32(a,5) + e + ((b & c) | (~b & d)) + 0x5a827999;
  71. e = d;
  72. d = c;
  73. c = ROTL32(b,30);
  74. b = a;
  75. a = g;
  76.     }
  77.     
  78.     for (; i<20*2; i++)
  79.     {
  80. g = (d ^ c ^ b) + e + ROTL32(g,5) + tmp[i] + 0x6ed9eba1;
  81. e = d;
  82. d = c;
  83. c = ROTL32(b,30);
  84. b = a;
  85. a = g;
  86.     }
  87.     
  88.     for (; i<20*3; i++)
  89.     {
  90. g = tmp[i] + ROTL32(g,5) + e + ((c & b) | (d & c) | (d & b)) - 0x70e44324;
  91. e = d;
  92. d = c;
  93. c = ROTL32(b,30);
  94. b = a;
  95. a = g;
  96.     }
  97.     
  98.     for (; i<20*4; i++)
  99.     {
  100. g = (d ^ c ^ b) + e + ROTL32(g,5) + tmp[i] - 0x359d3e2a;
  101. e = d;
  102. d = c;
  103. c = ROTL32(b,30);
  104. b = a;
  105. a = g;
  106.     }
  107.     
  108.     (*hash)[0] += g;
  109.     (*hash)[1] += b;
  110.     (*hash)[2] += c;
  111.     (*hash)[3] += d;
  112.     (*hash)[4] += e;
  113. }
  114. /*
  115.  * Fill 16 elements of the array of 32 bit values with the bytes from
  116.  * dst up to count in little endian order. Fill left over space with
  117.  * zeros
  118.  */
  119. static void hash_set_16(t_uint32 * dst, unsigned char const * src, unsigned int count)
  120. {
  121.     unsigned int i;
  122.     unsigned int pos;
  123.     
  124.     for (pos=0,i=0; i<16; i++)
  125.     {
  126. dst[i] = 0;
  127.         if (pos<count)
  128.     dst[i] |= ((t_uint32)src[pos]);
  129. pos++;
  130.         if (pos<count)
  131.     dst[i] |= ((t_uint32)src[pos])<<8;
  132. pos++;
  133.         if (pos<count)
  134.     dst[i] |= ((t_uint32)src[pos])<<16;
  135. pos++;
  136.         if (pos<count)
  137.     dst[i] |= ((t_uint32)src[pos])<<24;
  138. pos++;
  139.     }
  140. }
  141. extern int bnet_hash(t_hash * hashout, unsigned int size, void const * datain)
  142. {
  143.     t_uint32              tmp[64+16];
  144.     unsigned char const * data;
  145.     unsigned int          inc;
  146.     
  147.     if (!hashout || !*hashout)
  148.     {
  149. eventlog(eventlog_level_error,"bnet_hash","got NULL hashout");
  150. return -1;
  151.     }
  152.     if (size>0 && !datain)
  153.     {
  154. eventlog(eventlog_level_error,"bnet_hash","got NULL datain with size=%u",size);
  155. return -1;
  156.     }
  157.     
  158.     hash_init(hashout);
  159.     
  160.     data = datain;
  161.     while (size>0)
  162.     {
  163. if (size>64)
  164.     inc = 64;
  165. else
  166.     inc = size;
  167. hash_set_16(tmp,data,inc);
  168. do_hash(hashout,tmp);
  169. data += inc;
  170. size -= inc;
  171.     }
  172.     
  173.     return 0;
  174. }
  175. extern int hash_eq(t_hash const h1, t_hash const h2)
  176. {
  177.     unsigned int i;
  178.     
  179.     if (!h1 || !h2)
  180.     {
  181. eventlog(eventlog_level_error,"hash_eq","got NULL hash");
  182. return -1;
  183.     }
  184.     
  185.     for (i=0; i<5; i++)
  186. if (h1[i]!=h2[i])
  187.     return 0;
  188.     
  189.     return 1;
  190. }
  191. extern char const * hash_get_str(t_hash const hash)
  192. {
  193.     static char  temp[8*5+1]; /* each of 5 ints to 8 chars + null */
  194.     unsigned int i;
  195.     
  196.     if (!hash)
  197.     {
  198. eventlog(eventlog_level_error,"hash_get_str","got NULL hash");
  199. return NULL;
  200.     }
  201.     
  202.     for (i=0; i<5; i++)
  203.         sprintf(&temp[i*8],"%08x",hash[i]);
  204.     
  205.     return temp;
  206. }
  207. extern int hash_set_str(t_hash * hash, char const * str)
  208. {
  209.     unsigned int i;
  210.     
  211.     if (!hash)
  212.     {
  213. eventlog(eventlog_level_error,"hash_set_str","got NULL hash pointer");
  214.         return -1;
  215.     }
  216.     if (!*hash)
  217.     {
  218. eventlog(eventlog_level_error,"hash_set_str","got NULL hash");
  219.         return -1;
  220.     }
  221.     if (!str)
  222.     {
  223. eventlog(eventlog_level_error,"hash_set_str","got NULL str");
  224.         return -1;
  225.     }
  226.     if (strlen(str)!=5*8)
  227.     {
  228. eventlog(eventlog_level_error,"hash_set_str","got string with length %u (should be %u)",strlen(str),5*8);
  229.         return -1;
  230.     }
  231.     
  232.     for (i=0; i<5; i++)
  233.         if (sscanf(&str[i*8],"%8x",&(*hash)[i])!=1)
  234. {
  235.     eventlog(eventlog_level_error,"hash_set_str","got bad string");
  236.     return -1;
  237. }
  238.     
  239.     return 0;
  240. }