开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > P2P编程 > 查看源码
Sha.cpp
资源名称：GGBT.rar　[点击查看]
上传用户：lds876
上传日期：2013-05-25
资源大小：567k
文件大小：7k
源码类别：

P2P编程

开发平台：

Visual C++

Sha.cpp：源码内容
  1. // Sha.cpp: implementation of the CSha class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "Sha.h"
  7. #include <string.h>
  8. //#include "sha1.h"
  11. //////////////////////////////////////////////////////////////////////
  12. // Construction/Destruction
  13. //////////////////////////////////////////////////////////////////////
  16. #define GET_UINT32(n,b,i)                       
  17. {                                               
  18.     (n) = ( (uint32) (b)[(i)    ] << 24 )       
  19.         | ( (uint32) (b)[(i) + 1] << 16 )       
  20.         | ( (uint32) (b)[(i) + 2] <<  8 )       
  21.         | ( (uint32) (b)[(i) + 3]       );      
  22. }
  24. #define PUT_UINT32(n,b,i)                       
  25. {                                               
  26.     (b)[(i)    ] = (uint8) ( (n) >> 24 );       
  27.     (b)[(i) + 1] = (uint8) ( (n) >> 16 );       
  28.     (b)[(i) + 2] = (uint8) ( (n) >>  8 );       
  29.     (b)[(i) + 3] = (uint8) ( (n)       );       
  30. }
  32. void sha1_starts( struct sha1_context *ctx )
  33. {
  34.     ctx->total[0] = 0;
  35.     ctx->total[1] = 0;
  36.     ctx->state[0] = 0x67452301;
  37.     ctx->state[1] = 0xEFCDAB89;
  38.     ctx->state[2] = 0x98BADCFE;
  39.     ctx->state[3] = 0x10325476;
  40.     ctx->state[4] = 0xC3D2E1F0;
  41. }
  43. void sha1_process( struct sha1_context *ctx, uint8 data[64] )
  44. {
  45.     uint32 temp, A, B, C, D, E, W[16];
  47.     GET_UINT32( W[0],  data,  0 );
  48.     GET_UINT32( W[1],  data,  4 );
  49.     GET_UINT32( W[2],  data,  8 );
  50.     GET_UINT32( W[3],  data, 12 );
  51.     GET_UINT32( W[4],  data, 16 );
  52.     GET_UINT32( W[5],  data, 20 );
  53.     GET_UINT32( W[6],  data, 24 );
  54.     GET_UINT32( W[7],  data, 28 );
  55.     GET_UINT32( W[8],  data, 32 );
  56.     GET_UINT32( W[9],  data, 36 );
  57.     GET_UINT32( W[10], data, 40 );
  58.     GET_UINT32( W[11], data, 44 );
  59.     GET_UINT32( W[12], data, 48 );
  60.     GET_UINT32( W[13], data, 52 );
  61.     GET_UINT32( W[14], data, 56 );
  62.     GET_UINT32( W[15], data, 60 );
  64. #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
  66. #define R(t)                                            
  67. (                                                       
  68.     temp = W[(t -  3) & 0x0F] ^ W[(t - 8) & 0x0F] ^     
  69.            W[(t - 14) & 0x0F] ^ W[ t      & 0x0F],      
  70.     ( W[t & 0x0F] = S(temp,1) )                         
  71. )
  73. #define P(a,b,c,d,e,x)                                  
  74. {                                                       
  75.     e += S(a,5) + F(b,c,d) + K + x; b = S(b,30);        
  76. }
  78.     A = ctx->state[0];
  79.     B = ctx->state[1];
  80.     C = ctx->state[2];
  81.     D = ctx->state[3];
  82.     E = ctx->state[4];
  84. #define F(x,y,z) (z ^ (x & (y ^ z)))
  85. #define K 0x5A827999
  87.     P( A, B, C, D, E, W[0]  );
  88.     P( E, A, B, C, D, W[1]  );
  89.     P( D, E, A, B, C, W[2]  );
  90.     P( C, D, E, A, B, W[3]  );
  91.     P( B, C, D, E, A, W[4]  );
  92.     P( A, B, C, D, E, W[5]  );
  93.     P( E, A, B, C, D, W[6]  );
  94.     P( D, E, A, B, C, W[7]  );
  95.     P( C, D, E, A, B, W[8]  );
  96.     P( B, C, D, E, A, W[9]  );
  97.     P( A, B, C, D, E, W[10] );
  98.     P( E, A, B, C, D, W[11] );
  99.     P( D, E, A, B, C, W[12] );
  100.     P( C, D, E, A, B, W[13] );
  101.     P( B, C, D, E, A, W[14] );
  102.     P( A, B, C, D, E, W[15] );
  103.     P( E, A, B, C, D, R(16) );
  104.     P( D, E, A, B, C, R(17) );
  105.     P( C, D, E, A, B, R(18) );
  106.     P( B, C, D, E, A, R(19) );
  108. #undef K
  109. #undef F
  111. #define F(x,y,z) (x ^ y ^ z)
  112. #define K 0x6ED9EBA1
  114.     P( A, B, C, D, E, R(20) );
  115.     P( E, A, B, C, D, R(21) );
  116.     P( D, E, A, B, C, R(22) );
  117.     P( C, D, E, A, B, R(23) );
  118.     P( B, C, D, E, A, R(24) );
  119.     P( A, B, C, D, E, R(25) );
  120.     P( E, A, B, C, D, R(26) );
  121.     P( D, E, A, B, C, R(27) );
  122.     P( C, D, E, A, B, R(28) );
  123.     P( B, C, D, E, A, R(29) );
  124.     P( A, B, C, D, E, R(30) );
  125.     P( E, A, B, C, D, R(31) );
  126.     P( D, E, A, B, C, R(32) );
  127.     P( C, D, E, A, B, R(33) );
  128.     P( B, C, D, E, A, R(34) );
  129.     P( A, B, C, D, E, R(35) );
  130.     P( E, A, B, C, D, R(36) );
  131.     P( D, E, A, B, C, R(37) );
  132.     P( C, D, E, A, B, R(38) );
  133.     P( B, C, D, E, A, R(39) );
  135. #undef K
  136. #undef F
  138. #define F(x,y,z) ((x & y) | (z & (x | y)))
  139. #define K 0x8F1BBCDC
  141.     P( A, B, C, D, E, R(40) );
  142.     P( E, A, B, C, D, R(41) );
  143.     P( D, E, A, B, C, R(42) );
  144.     P( C, D, E, A, B, R(43) );
  145.     P( B, C, D, E, A, R(44) );
  146.     P( A, B, C, D, E, R(45) );
  147.     P( E, A, B, C, D, R(46) );
  148.     P( D, E, A, B, C, R(47) );
  149.     P( C, D, E, A, B, R(48) );
  150.     P( B, C, D, E, A, R(49) );
  151.     P( A, B, C, D, E, R(50) );
  152.     P( E, A, B, C, D, R(51) );
  153.     P( D, E, A, B, C, R(52) );
  154.     P( C, D, E, A, B, R(53) );
  155.     P( B, C, D, E, A, R(54) );
  156.     P( A, B, C, D, E, R(55) );
  157.     P( E, A, B, C, D, R(56) );
  158.     P( D, E, A, B, C, R(57) );
  159.     P( C, D, E, A, B, R(58) );
  160.     P( B, C, D, E, A, R(59) );
  162. #undef K
  163. #undef F
  165. #define F(x,y,z) (x ^ y ^ z)
  166. #define K 0xCA62C1D6
  168.     P( A, B, C, D, E, R(60) );
  169.     P( E, A, B, C, D, R(61) );
  170.     P( D, E, A, B, C, R(62) );
  171.     P( C, D, E, A, B, R(63) );
  172.     P( B, C, D, E, A, R(64) );
  173.     P( A, B, C, D, E, R(65) );
  174.     P( E, A, B, C, D, R(66) );
  175.     P( D, E, A, B, C, R(67) );
  176.     P( C, D, E, A, B, R(68) );
  177.     P( B, C, D, E, A, R(69) );
  178.     P( A, B, C, D, E, R(70) );
  179.     P( E, A, B, C, D, R(71) );
  180.     P( D, E, A, B, C, R(72) );
  181.     P( C, D, E, A, B, R(73) );
  182.     P( B, C, D, E, A, R(74) );
  183.     P( A, B, C, D, E, R(75) );
  184.     P( E, A, B, C, D, R(76) );
  185.     P( D, E, A, B, C, R(77) );
  186.     P( C, D, E, A, B, R(78) );
  187.     P( B, C, D, E, A, R(79) );
  189. #undef K
  190. #undef F
  192.     ctx->state[0] += A;
  193.     ctx->state[1] += B;
  194.     ctx->state[2] += C;
  195.     ctx->state[3] += D;
  196.     ctx->state[4] += E;
  197. }
  199. void sha1_update( struct sha1_context *ctx, uint8 *input, uint32 length )
  200. {
  201.     uint32 left, fill;
  203.     if( ! length ) return;
  205.     left = ( ctx->total[0] >> 3 ) & 0x3F;
  206.     fill = 64 - left;
  208.     ctx->total[0] += length <<  3;
  209.     ctx->total[1] += length >> 29;
  211.     ctx->total[0] &= 0xFFFFFFFF;
  212.     ctx->total[1] += ctx->total[0] < ( length << 3 );
  214.     if( left && length >= fill )
  215.     {
  216.         memcpy( (void *) (ctx->buffer + left), (void *) input, fill );
  217.         sha1_process( ctx, ctx->buffer );
  218.         length -= fill;
  219.         input  += fill;
  220.         left = 0;
  221.     }
  223.     while( length >= 64 )
  224.     {
  225.         sha1_process( ctx, input );
  226.         length -= 64;
  227.         input  += 64;
  228.     }
  230.     if( length )
  231.     {
  232.         memcpy( (void *) (ctx->buffer + left), (void *) input, length );
  233.     }
  234. }
  236. static uint8 sha1_padding[64] =
  237. {
  238.  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  239.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  240.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  241.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  242. };
  244. void sha1_finish( struct sha1_context *ctx, uint8 digest[20] )
  245. {
  246.     uint32 last, padn;
  247.     uint8 msglen[8];
  249.     PUT_UINT32( ctx->total[1], msglen, 0 );
  250.     PUT_UINT32( ctx->total[0], msglen, 4 );
  252.     last = ( ctx->total[0] >> 3 ) & 0x3F;
  253.     padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
  255.     sha1_update( ctx, sha1_padding, padn );
  256.     sha1_update( ctx, msglen, 8 );
  258.     PUT_UINT32( ctx->state[0], digest,  0 );
  259.     PUT_UINT32( ctx->state[1], digest,  4 );
  260.     PUT_UINT32( ctx->state[2], digest,  8 );
  261.     PUT_UINT32( ctx->state[3], digest, 12 );
  262.     PUT_UINT32( ctx->state[4], digest, 16 );
  263. }
  265. void CSHA::start()
  266. {
  267. sha1_starts(&m_ctx);
  268. }
  270. void CSHA::update(uint8 *input, uint32 length )
  271. {
  272. sha1_update(&m_ctx, input, length);
  273. }
  275. void CSHA::finish(uint8 digest[])
  276. {
  277. sha1_finish(&m_ctx, digest);
  278. }