安全散列算法SHA1，主要用于数字签名。输入数据的最大长度为2^64,输出为160位的散列函数值。

SHA1代码：

 

 
  
  1. #include<stdio.h> 
  2. #include<stdlib.h> 
  3. #include<time.h> 
  4.  
  5. unsigned int H[5] = {0x67452301,0xefcdab89,0x98badcfe,0x10325476,0xc3d2e1f0}; 
  6. unsigned int K[4] = {0x5a827999,0x6ed9eba1,0x8f1bbcdc,0xca62c1d6}; 
  7.  
  8. unsigned int M[16]; 
  9. unsigned int W[80]; 
  10. unsigned char LastString[512/8*2];//将最后多余部分拿出，和补的位存放于此 
  11. unsigned int A,B,C,D,E; 
  12.  
  13. FILE * fp; 
  14. fpos_t pos; //文件长度 
  15. int flag ;  
  16. int LastRoundCount; 
  17.  
  18. int GetMessage(unsigned long long rLen); 
  19. void SetW(); 
  20. void Round(); 
  21.  
  22. int main(int argc, char *argv[]) 
  23. { 
  24.     if(argc == 1) 
  25.     { 
  26.         printf("请输入要hash的文件名！\n"); 
  27.         exit(0); 
  28.     } 
  29.     fp = fopen(argv[1],"rb"); 
  30.      
  31.     clock_t start, finish;  //计时 
  32.     start = clock();   
  33.      
  34.     fseek(fp, 0, SEEK_END); 
  35.     fgetpos(fp, &pos); 
  36.     unsigned long long realLen = pos; 
  37.      
  38.     memset(LastString,0x00,strlen(LastString)*sizeof(unsigned char));//初始化 
  39.      
  40.     int LastOut = realLen%(512/8); 
  41.     fseek(fp,-1*LastOut,SEEK_END); 
  42.      
  43.     int i; 
  44.     fread(LastString,LastOut,1,fp);//将多余部分复制到LastString 
  45.     LastString[LastOut] = 0x80;  
  46.      
  47.     LastRoundCount = 1; 
  48.     flag = 0; 
  49. //  unsigned long long copyLen = realLen<<3; 
  50.     if(LastOut <=55)            //将长度放在末尾 
  51.     { 
  52.         flag = 1; 
  53.     //  memcpy(LastString+512/8-8,&copyLen,8); 
  54.         for( i = 8; i >= 1; i--) 
  55.             LastString[512/8 - i] = (char)((realLen<<3)>>((i-1)*8));   
  56.     } 
  57.     else 
  58.     { 
  59.         flag = 2; 
  60.     //  memcpy(LastString+512/8*2-8,&copyLen,8); 
  61.         for( i = 1; i <= 8; i++) 
  62.             LastString[512/8*2 - i] = (char)((realLen<<3)>>((i-1)*8));   
  63.     } 
  64.  
  65.     realLen -= LastOut; //长度变短 
  66.  
  67.     fseek(fp,0,SEEK_SET); 
  68.      
  69.     while(GetMessage(realLen)) 
  70.     { 
  71.         SetW(); 
  72.         Round(); 
  73. //      printf("."); 
  74.     } 
  75.      
  76.     printf("SHA1:  "); 
  77.     for(i = 0 ; i < 5; i++) 
  78.         printf("%08x ",H[i]); 
  79.     printf("\n");  
  80.      
  81.     finish = clock();   
  82.     double duration = (double)(finish - start) / CLOCKS_PER_SEC;  
  83.     printf("Cal time: %f seconds\n",duration); 
  84.     fclose(fp); 
  85.     return 0; 
  86. } 
  87.  
  88. int GetMessage(unsigned long long rLen) 
  89. { 
  90.     fgetpos(fp, &pos); 
  91.  
  92.     if(pos + 16 * 4 <= rLen) 
  93.     { 
  94.         fread(M,4,16,fp);//注意M的读入，读入之后M的四个字节是反过来的，应该是编码方式的问题，big-edi和little-edi 
  95.         return 1;           //所以后面存到W时要移位操作，此处这样操作，读入速度变快 
  96.     } 
  97.      
  98.     if(LastRoundCount <= flag) 
  99.     { 
  100.         memcpy(M,(LastString+512/8*(LastRoundCount - 1)),64);//最后的一段或是两段 
  101.         LastRoundCount++; 
  102.         return 1; 
  103.     } 
  104.     else 
  105.         return 0; //false; 
  106.  
  107. } 
  108. void SetW() 
  109. { 
  110.     int index = 0; 
  111.     for(index = 0; index <=15;index++) 
  112.     {   //编码方式，M的四个字节的顺序是反过来的，将其移位 
  113.         W[index] = (M[index]>>24)|(M[index]<<24)|((M[index]&0x00ff0000)>>8)|((M[index]&0x0000ff00)<<8); 
  114.     }  
  115.  
  116.     for(index = 16;index<=79;index++) 
  117.     { 
  118.         unsigned int temp = W[index -16]^W[index - 14]^W[index - 8]^W[index - 3]; 
  119.         W[index] = (temp<<1)|(temp>>(32 -1)); 
  120.     } 
  121. } 
  122.  
  123. void Round() 
  124. { 
  125.     A = H[0]; 
  126.     B = H[1]; 
  127.     C = H[2]; 
  128.     D = H[3]; 
  129.     E = H[4]; 
  130.     int index = 0; 
  131.     unsigned int temp; 
  132.     for(index = 0;index <=79;index++) 
  133.     { 
  134.         if(index >= 0 && index <=19) 
  135.             temp = E + ((B&C)|(~B&D)) + ((A<<5)|(A>>(32-5))) + W[index] + K[0]; 
  136.         else if(index >= 20 && index <=39) 
  137.             temp = E + (B^C^D) + ((A<<5)|(A>>(32-5))) + W[index] + K[1]; 
  138.         else if(index >= 40 && index <=59) 
  139.             temp = E + ((B&C)|(C&D)|(B&D)) + ((A<<5)|(A>>(32-5))) + W[index] + K[2]; 
  140.         else if(index >= 60 && index <=79) 
  141.             temp = E + (B^C^D) + + ((A<<5)|(A>>(32-5))) + W[index] + K[3]; 
  142.  
  143.         E = D; 
  144.         D = C; 
  145.         C = (B<<30)|(B>>(32-30)); 
  146.         B = A; 
  147.         A = temp; 
  148.     } 
  149.  
  150.     H[0]+=A; 
  151.     H[1]+=B; 
  152.     H[2]+=C; 
  153.     H[3]+=D; 
  154.     H[4]+=E; 
  155. } 
  156.  
 
  
实验环境：gcc编译器
 
  
若使用VC++，则需将unsigned long long 替换为 unsigned __int64，输入输出函数参数可能需改变。
 
  
对于任意长度的输入，散列函数得到的输出长度是一样的，这是散列函数的特点。
 
  
 
  
 
  
 
  
微小改变带来巨大差别，这是散列函数的另一个特点。