同样的代码在SCO和AIX算出SHA-1值不一样，什么原因

cl02050212

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <assert.h>
   
5. #include <errno.h>
   
6. 
   
7. #define BIG_ENDIAN_HOST 1
   
8. typedef unsigned int u32;
   
9. 
   
10. /****************
    
11. * Rotate a 32 bit integer by n bytes
    
12. ****************/
    
13. #if defined(__GNUC__) && defined(__i386__)
    
14. static inline u32 rol( u32 x, int n)
    
15. {
    
16. __asm__("roll %%cl,%0"
    
17.             :"=r" (x)
    
18.             :"0" (x),"c" (n));
    
19. return x;
    
20. }
    
21. #else
    
22. #define rol(x,n) ( ((x) << (n)) | ((x) >> (32-(n))) )
    
23. #endif
    
24. 
    
25. 
    
26. typedef struct {
    
27.     u32 h0,h1,h2,h3,h4;
    
28.     u32 nblocks;
    
29.     unsigned char buf[64];
    
30.     int count;
    
31. } SHA1_CONTEXT;
    
32. 
    
33. 
    
34. 
    
35. void sha1_init( SHA1_CONTEXT *hd )
    
36. {
    
37.     hd->h0 = 0x67452301;
    
38.     hd->h1 = 0xefcdab89;
    
39.     hd->h2 = 0x98badcfe;
    
40.     hd->h3 = 0x10325476;
    
41.     hd->h4 = 0xc3d2e1f0;
    
42.     hd->nblocks = 0;
    
43.     hd->count = 0;
    
44. }
    
45. 
    
46. 
    
47. /*
    
48. * Transform the message X which consists of 16 32-bit-words
    
49. */
    
50. static void
    
51. transform( SHA1_CONTEXT *hd, unsigned char *data )
    
52. {
    
53.     u32 a,b,c,d,e,tm;
    
54.     u32 x[16];
    
55. 
    
56.     /* get values from the chaining vars */
    
57.     a = hd->h0;
    
58.     b = hd->h1;
    
59.     c = hd->h2;
    
60.     d = hd->h3;
    
61.     e = hd->h4;
    
62. 
    
63. #ifdef BIG_ENDIAN_HOST
    
64.     memcpy( x, data, 64 );
    
65. #else
    
66.     { int i;
    
67.         unsigned char *p2;
    
68.         for(i=0, p2=(unsigned char*)x; i < 16; i++, p2 += 4 ) {
    
69.             p2[3] = *data++;
    
70.             p2[2] = *data++;
    
71.             p2[1] = *data++;
    
72.             p2[0] = *data++;
    
73.         }
    
74.     }
    
75. #endif
    
76. 
    
77. 
    
78. #define K1 0x5A827999L
    
79. #define K2 0x6ED9EBA1L
    
80. #define K3 0x8F1BBCDCL
    
81. #define K4 0xCA62C1D6L
    
82. #define F1(x,y,z)   ( z ^ ( x & ( y ^ z ) ) )
    
83. #define F2(x,y,z)   ( x ^ y ^ z )
    
84. #define F3(x,y,z)   ( ( x & y ) | ( z & ( x | y ) ) )
    
85. #define F4(x,y,z)   ( x ^ y ^ z )
    
86. 
    
87. 
    
88. #define M(i) ( tm =   x[i&0x0f] ^ x[(i-14)&0x0f]    \
    
89.                ^ x[(i-8)&0x0f] ^ x[(i-3)&0x0f]      \
    
90.                , (x[i&0x0f] = rol(tm,1)) )
    
91. 
    
92. #define R(a,b,c,d,e,f,k,m) do { e += rol( a, 5 )   \
    
93.             + f( b, c, d )                          \
    
94.             + k                                     \
    
95.             + m;                                    \
    
96.         b = rol( b, 30 );                           \
    
97.     } while(0)
    
98.     R( a, b, c, d, e, F1, K1, x[ 0] );
    
99.     R( e, a, b, c, d, F1, K1, x[ 1] );
    
100.     R( d, e, a, b, c, F1, K1, x[ 2] );
     
101.     R( c, d, e, a, b, F1, K1, x[ 3] );
     
102.     R( b, c, d, e, a, F1, K1, x[ 4] );
     
103.     R( a, b, c, d, e, F1, K1, x[ 5] );
     
104.     R( e, a, b, c, d, F1, K1, x[ 6] );
     
105.     R( d, e, a, b, c, F1, K1, x[ 7] );
     
106.     R( c, d, e, a, b, F1, K1, x[ 8] );
     
107.     R( b, c, d, e, a, F1, K1, x[ 9] );
     
108.     R( a, b, c, d, e, F1, K1, x[10] );
     
109.     R( e, a, b, c, d, F1, K1, x[11] );
     
110.     R( d, e, a, b, c, F1, K1, x[12] );
     
111.     R( c, d, e, a, b, F1, K1, x[13] );
     
112.     R( b, c, d, e, a, F1, K1, x[14] );
     
113.     R( a, b, c, d, e, F1, K1, x[15] );
     
114.     R( e, a, b, c, d, F1, K1, M(16) );
     
115.     R( d, e, a, b, c, F1, K1, M(17) );
     
116.     R( c, d, e, a, b, F1, K1, M(18) );
     
117.     R( b, c, d, e, a, F1, K1, M(19) );
     
118.     R( a, b, c, d, e, F2, K2, M(20) );
     
119.     R( e, a, b, c, d, F2, K2, M(21) );
     
120.     R( d, e, a, b, c, F2, K2, M(22) );
     
121.     R( c, d, e, a, b, F2, K2, M(23) );
     
122.     R( b, c, d, e, a, F2, K2, M(24) );
     
123.     R( a, b, c, d, e, F2, K2, M(25) );
     
124.     R( e, a, b, c, d, F2, K2, M(26) );
     
125.     R( d, e, a, b, c, F2, K2, M(27) );
     
126.     R( c, d, e, a, b, F2, K2, M(28) );
     
127.     R( b, c, d, e, a, F2, K2, M(29) );
     
128.     R( a, b, c, d, e, F2, K2, M(30) );
     
129.     R( e, a, b, c, d, F2, K2, M(31) );
     
130.     R( d, e, a, b, c, F2, K2, M(32) );
     
131.     R( c, d, e, a, b, F2, K2, M(33) );
     
132.     R( b, c, d, e, a, F2, K2, M(34) );
     
133.     R( a, b, c, d, e, F2, K2, M(35) );
     
134.     R( e, a, b, c, d, F2, K2, M(36) );
     
135.     R( d, e, a, b, c, F2, K2, M(37) );
     
136.     R( c, d, e, a, b, F2, K2, M(38) );
     
137.     R( b, c, d, e, a, F2, K2, M(39) );
     
138.     R( a, b, c, d, e, F3, K3, M(40) );
     
139.     R( e, a, b, c, d, F3, K3, M(41) );
     
140.     R( d, e, a, b, c, F3, K3, M(42) );
     
141.     R( c, d, e, a, b, F3, K3, M(43) );
     
142.     R( b, c, d, e, a, F3, K3, M(44) );
     
143.     R( a, b, c, d, e, F3, K3, M(45) );
     
144.     R( e, a, b, c, d, F3, K3, M(46) );
     
145.     R( d, e, a, b, c, F3, K3, M(47) );
     
146.     R( c, d, e, a, b, F3, K3, M(48) );
     
147.     R( b, c, d, e, a, F3, K3, M(49) );
     
148.     R( a, b, c, d, e, F3, K3, M(50) );
     
149.     R( e, a, b, c, d, F3, K3, M(51) );
     
150.     R( d, e, a, b, c, F3, K3, M(52) );
     
151.     R( c, d, e, a, b, F3, K3, M(53) );
     
152.     R( b, c, d, e, a, F3, K3, M(54) );
     
153.     R( a, b, c, d, e, F3, K3, M(55) );
     
154.     R( e, a, b, c, d, F3, K3, M(56) );
     
155.     R( d, e, a, b, c, F3, K3, M(57) );
     
156.     R( c, d, e, a, b, F3, K3, M(58) );
     
157.     R( b, c, d, e, a, F3, K3, M(59) );
     
158.     R( a, b, c, d, e, F4, K4, M(60) );
     
159.     R( e, a, b, c, d, F4, K4, M(61) );
     
160.     R( d, e, a, b, c, F4, K4, M(62) );
     
161.     R( c, d, e, a, b, F4, K4, M(63) );
     
162.     R( b, c, d, e, a, F4, K4, M(64) );
     
163.     R( a, b, c, d, e, F4, K4, M(65) );
     
164.     R( e, a, b, c, d, F4, K4, M(66) );
     
165.     R( d, e, a, b, c, F4, K4, M(67) );
     
166.     R( c, d, e, a, b, F4, K4, M(68) );
     
167.     R( b, c, d, e, a, F4, K4, M(69) );
     
168.     R( a, b, c, d, e, F4, K4, M(70) );
     
169.     R( e, a, b, c, d, F4, K4, M(71) );
     
170.     R( d, e, a, b, c, F4, K4, M(72) );
     
171.     R( c, d, e, a, b, F4, K4, M(73) );
     
172.     R( b, c, d, e, a, F4, K4, M(74) );
     
173.     R( a, b, c, d, e, F4, K4, M(75) );
     
174.     R( e, a, b, c, d, F4, K4, M(76) );
     
175.     R( d, e, a, b, c, F4, K4, M(77) );
     
176.     R( c, d, e, a, b, F4, K4, M(78) );
     
177.     R( b, c, d, e, a, F4, K4, M(79) );
     
178. 
     
179.     /* Update chaining vars */
     
180.     hd->h0 += a;
     
181.     hd->h1 += b;
     
182.     hd->h2 += c;
     
183.     hd->h3 += d;
     
184.     hd->h4 += e;
     
185. }
     
186. 
     
187. 
     
188. /* Update the message digest with the contents
     
189. * of INBUF with length INLEN.
     
190. */
     
191. static void sha1_write( SHA1_CONTEXT *hd, unsigned char *inbuf, size_t inlen)
     
192. {
     
193.     if( hd->count == 64 ) { /* flush the buffer */
     
194.         transform( hd, hd->buf );
     
195.         hd->count = 0;
     
196.         hd->nblocks++;
     
197.     }
     
198.     if( !inbuf )
     
199.         return;
     
200.     if( hd->count ) {
     
201.         for( ; inlen && hd->count < 64; inlen-- )
     
202.             hd->buf[hd->count++] = *inbuf++;
     
203.         sha1_write( hd, NULL, 0 );
     
204.         if( !inlen )
     
205.             return;
     
206.     }
     
207. 
     
208.     while( inlen >= 64 ) {
     
209.         transform( hd, inbuf );
     
210.         hd->count = 0;
     
211.         hd->nblocks++;
     
212.         inlen -= 64;
     
213.         inbuf += 64;
     
214.     }
     
215.     for( ; inlen && hd->count < 64; inlen-- )
     
216.         hd->buf[hd->count++] = *inbuf++;
     
217. }
     
218. 
     
219. 
     
220. /* The routine final terminates the computation and
     
221. * returns the digest.
     
222. * The handle is prepared for a new cycle, but adding bytes to the
     
223. * handle will the destroy the returned buffer.
     
224. * Returns: 20 bytes representing the digest.
     
225. */
     
226. 
     
227. static void sha1_final(SHA1_CONTEXT *hd)
     
228. {
     
229.     u32 t, msb, lsb;
     
230.     unsigned char *p;
     
231. 
     
232.     sha1_write(hd, NULL, 0); /* flush */;
     
233. 
     
234.     t = hd->nblocks;
     
235.     /* multiply by 64 to make a byte count */
     
236.     lsb = t << 6;
     
237.     msb = t >> 26;
     
238.     /* add the count */
     
239.     t = lsb;
     
240.     if( (lsb += hd->count) < t )
     
241.         msb++;
     
242.     /* multiply by 8 to make a bit count */
     
243.     t = lsb;
     
244.     lsb <<= 3;
     
245.     msb <<= 3;
     
246.     msb |= t >> 29;
     
247. 
     
248.     if( hd->count < 56 ) { /* enough room */
     
249.         hd->buf[hd->count++] = 0x80; /* pad */
     
250.         while( hd->count < 56 )
     
251.             hd->buf[hd->count++] = 0; /* pad */
     
252.     }
     
253.     else { /* need one extra block */
     
254.         hd->buf[hd->count++] = 0x80; /* pad character */
     
255.         while( hd->count < 64 )
     
256.             hd->buf[hd->count++] = 0;
     
257.         sha1_write(hd, NULL, 0); /* flush */;
     
258.         memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
     
259.     }
     
260.     /* append the 64 bit count */
     
261.     hd->buf[56] = msb >> 24;
     
262.     hd->buf[57] = msb >> 16;
     
263.     hd->buf[58] = msb >> 8;
     
264.     hd->buf[59] = msb    ;
     
265.     hd->buf[60] = lsb >> 24;
     
266.     hd->buf[61] = lsb >> 16;
     
267.     hd->buf[62] = lsb >> 8;
     
268.     hd->buf[63] = lsb    ;
     
269.     transform( hd, hd->buf );
     
270. 
     
271.     p = hd->buf;
     
272. #ifdef BIG_ENDIAN_HOST
     
273. #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
     
274. #else /* little endian */
     
275. #define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16; \
     
276.         *p++ = hd->h##a >> 8; *p++ = hd->h##a; } while(0)
     
277. #endif
     
278.     X(0);
     
279.     X(1);
     
280.     X(2);
     
281.     X(3);
     
282.     X(4);
     
283. #undef X
     
284. }
     
285. 
     
286. /**
     
287. * SHA1_Verify_File - Verify the file
     
288. * in:
     
289. *    @file: input file
     
290. * out:
     
291. *    @sha1_value: SHA-1 value
     
292. */
     
293. int SHA1_Verify_File( const char *file, char *sha1_value )
     
294. {
     
295.     FILE *fp = NULL;
     
296.     unsigned char buffer[4096] = {0};
     
297.     size_t n = 0;
     
298.     SHA1_CONTEXT ctx;
     
299.     int i = 0;
     
300. 
     
301.     assert( sizeof(u32) == 4 );
     
302.     assert( sha1_value != NULL );
     
303. 
     
304.     fp = fopen( file, "rb" );
     
305.     if( !fp ) {
     
306.         return -1;
     
307.     }
     
308.     sha1_init( &ctx );
     
309.     while( ( n = fread( buffer, 1, sizeof buffer, fp) ) )
     
310.         sha1_write( &ctx, buffer, n );
     
311.     if( ferror(fp) ) {
     
312.         return -2;
     
313.     }
     
314.     sha1_final( &ctx );
     
315.     fclose( fp );
     
316. 
     
317.     for( i=0; i < 20; i++ ) {
     
318.         sprintf( sha1_value, "%s%02x", sha1_value, ctx.buf[i] );
     
319.     }
     
320.     return 0;
     
321. }
     
322. 
     
323. /**
     
324. * SHA1_Verify_Buffer - Verify the memory buffer
     
325. * in:
     
326. *    @buffer: buffer
     
327. *    @buflen: buffer len
     
328. * out:
     
329. *    @sha1_value: SHA-1 value
     
330. */
     
331. int SHA1_Verify_Buffer( unsigned char *buffer, int buflen, char *sha1_value )
     
332. {
     
333.     SHA1_CONTEXT ctx;
     
334.     size_t iSize = buflen;
     
335.     int i = 0;
     
336. 
     
337.     assert( sizeof(u32) == 4 );
     
338.     assert( sha1_value != NULL );
     
339.     assert( buffer != NULL );
     
340. 
     
341.     sha1_init( &ctx );
     
342.     sha1_write( &ctx, buffer, iSize );
     
343.     sha1_final( &ctx );
     
344. 
     
345.     for( i=0; i < 20; i++ ) {
     
346.         sprintf( sha1_value, "%s%02x", sha1_value, ctx.buf[i] );
     
347.     }
     
348.     return 0;
     
349. }
     
350. /*
     
351. int AppVerMac( PFS epfsAddr, char *epczBuffer, int eiLen )
     
352. {
     
353.    char acMac[ 40+1 ] = {0};
     
354.    int i = 0;
     
355.    SHA1_Verify_Buffer( (unsigned char*)(epczBuffer), eiLen, acMac );
     
356. 
     
357.    for( i=0; i<strlen(acMac); i++ ) {
     
358.       acMac[i] = toupper( acMac[i] );
     
359.    }
     
360. 
     
361.    if( strncmp( stIbsHead.gwMac, acMac, 40 ) ) {
     
362.       return -1;
     
363.    } else  {
     
364.    }
     
365.    return 0;
     
366. }
     
367. */
     
368. 
     
369. int AppGenMac( char *gwMac, char *epczBuffer, int eiLen )
     
370. {
     
371.    char acMac[ 40+1 ] = {0};
     
372.    int i = 0;
     
373. 
     
374.    SHA1_Verify_Buffer( (unsigned char*)(epczBuffer), eiLen, acMac );
     
375. 
     
376.    /* convert to upper case */
     
377.    for( i=0; i<strlen(acMac); i++ ) {
     
378.       acMac[i] = toupper( acMac[i] );
     
379.    }
     
380. 
     
381.    strncpy( gwMac, acMac, 40 );
     
382.    return 0;
     
383. }
     
384. 
     
385. int main()
     
386. {
     
387.         char a[5];
     
388.         char g[40+1];
     
389.         int i=0;
     
390. 
     
391.         memset( a, 0x00, sizeof( a ) );
     
392.         memset( g, 0x00, sizeof( g ) );
     
393. 
     
394.         strncpy(a,"<>",2);
     
395.         i=AppGenMac( g, a, 2 );
     
396.         printf("%s\n\n",g);
     
397.         return 0;
     
398. }

复制代码

ddm95

big endian/little endian, 32/64

folklore

SHA-1算法本身本来就没有要求一样。
实现本来就可以有差异，
正如C语言的很多编译器彼此都有点差异一样。

又不是像MD5这种算法，
算出来结果一定一样。

hellioncu

在非BIG_ENDIAN的环境，把#define BIG_ENDIAN_HOST 1这一行注释掉试试

cl02050212

回复 4# hellioncu

按你的方法解决了，谢谢


   

cl02050212

hellioncu 发表于 2014-06-11 08:41
在非BIG_ENDIAN的环境，把#define BIG_ENDIAN_HOST 1这一行注释掉试试

按此方法解决了，谢谢