SHA1算法实现及详解

最新推荐文章于 2024-06-17 11:29:13 发布
最新推荐文章于 2024-06-17 11:29:13 发布
阅读量3.2w 收藏 16
点赞数 6
分类专栏： 网络协议 文章标签： 算法 byte string output c input

1 SHA1算法简介

安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。

SHA1有如下特性：不可以从消息摘要中复原信息；两个不同的消息不会产生同样的消息摘要。

2 术语和概念

2.1位(Bit)，字节（Byte）和字（Word）

SHA1始终把消息当成一个位（bit）字符串来处理。本文中，一个“字”（Word）是32位，而一个“字节”（Byte）是8位。比如，字符串“abc”可以被转换成一个位字符串：01100001 01100010 01100011。它也可以被表示成16进制字符串: 0x616263.

2.2 运算符和符号

下面的逻辑运算符都被运用于“字”（Word）

X^Y    = X， Y逻辑与

X \/ Y   = X， Y逻辑或

X XOR Y= X， Y逻辑异或

~X     =   X逻辑取反

X+Y定义如下：

字 X 和 Y 代表两个整数 x 和y, 其中 0 <= x < 2^32 且 0 <= y < 2^32. 令整数z = (x + y) mod 2^32. 这时候 0 <= z < 2^32. 将z转换成字Z, 那么就是 Z = X + Y.

循环左移位操作符Sn(X)。X是一个字，n是一个整数，0<=n<=32。Sn(X) = (X<<n)OR(X>>32-n)

X<<n定义如下：抛弃最左边的n位数字，将各个位依次向左移动n位，然后用0填补右边的n位（最后结果还是32位）。X>>n是抛弃右边的n位，将各个位依次向右移动n位，然后在左边的n位填0。因此可以叫Sn(X)位循环移位运算

3 SHA1算法描述

在SHA1算法中，我们必须把原始消息（字符串，文件等）转换成位字符串。SHA1算法只接受位作为输入。假设我们对字符串“abc”产生消息摘要。首先，我们将它转换成位字符串如下：

01100001 01100010 01100011

―――――――――――――

‘a’=97   ‘b’=98   ‘c’=99

这个位字符串的长度为24。下面我们需要5个步骤来计算MD5。

3.1 补位

       消息必须进行补位，以使其长度在对512取模以后的余数是448。也就是说，（补位后的消息长度）%512 = 448。即使长度已经满足对512取模后余数是448，补位也必须要进行。

       补位是这样进行的：先补一个1，然后再补0，直到长度满足对512取模后余数是448。总而言之，补位是至少补一位，最多补512位。还是以前面的“abc”为例显示补位的过程。

原始信息： 01100001 01100010 01100011

补位第一步：01100001 01100010 01100011 1

                                                               首先补一个“1”

补位第二步：01100001 01100010 01100011 10…..0

                                                               然后补423个“0”

我们可以把最后补位完成后的数据用16进制写成下面的样子

61626380 00000000 00000000 00000000

00000000 00000000 00000000 00000000

00000000 00000000 00000000 00000000

00000000 00000000

现在，数据的长度是448了，我们可以进行下一步操作。

3.2 补长度

       所谓的补长度是将原始数据的长度补到已经进行了补位操作的消息后面。通常用一个64位的数据来表示原始消息的长度。如果消息长度不大于2^64，那么第一个字就是0。在进行了补长度的操作以后，整个消息就变成下面这样了（16进制格式）

61626380 00000000 00000000 00000000

00000000 00000000 00000000 00000000

00000000 00000000 00000000 00000000

00000000 00000000 00000000 00000018

如果原始的消息长度超过了512，我们需要将它补成512的倍数。然后我们把整个消息分成一个一个512位的数据块，分别处理每一个数据块，从而得到消息摘要。

3.3 使用的常量

一系列的常量字K(0), K(1), ... , K(79)，如果以16进制给出。它们如下：

Kt = 0x5A827999  (0 <= t <= 19)

Kt = 0x6ED9EBA1 (20 <= t <= 39)

Kt = 0x8F1BBCDC (40 <= t <= 59)

Kt = 0xCA62C1D6 (60 <= t <= 79).

3.4 需要使用的函数

在SHA1中我们需要一系列的函数。每个函数ft (0 <= t <= 79)都操作32位字B，C，D并且产生32位字作为输出。ft(B,C,D)可以如下定义

ft(B,C,D) = (B AND C) OR ((NOT B) AND D) ( 0 <= t <= 19)

ft(B,C,D) = B XOR C XOR D             (20 <= t <= 39)

ft(B,C,D) = (B AND C) OR (B AND D) OR (C AND D) (40 <= t <= 59)

ft(B,C,D) = B XOR C XOR D                    (60 <= t <= 79).

3.5 计算消息摘要

必须使用进行了补位和补长度后的消息来计算消息摘要。计算需要两个缓冲区，每个都由5个32位的字组成，还需要一个80个32位字的缓冲区。第一个5个字的缓冲区被标识为A，B，C，D，E。第一个5个字的缓冲区被标识为H0, H1, H2, H3, H4

。80个字的缓冲区被标识为W0, W1,..., W79


另外还需要一个一个字的TEMP缓冲区。

为了产生消息摘要，在第4部分中定义的16个字的数据块M1, M2,..., Mn

会依次进行处理，处理每个数据块Mi 包含80个步骤。

在处理每个数据块之前，缓冲区{Hi} 被初始化为下面的值（16进制）

H0 = 0x67452301

H1 = 0xEFCDAB89

H2 = 0x98BADCFE

H3 = 0x10325476

H4 = 0xC3D2E1F0.
现在开始处理M1, M2, ... , Mn。为了处理 Mi,需要进行下面的步骤

(1). 将 Mi 分成 16 个字 W0, W1, ... , W15,  W0 是最左边的字

(2). 对于 t = 16 到 79 令 Wt = S1(Wt-3 XOR Wt-8 XOR Wt- 14 XOR Wt-16).

(3). 令 A = H0, B = H1, C = H2, D = H3, E = H4.

(4) 对于 t = 0 到 79，执行下面的循环

TEMP = S5(A) + ft(B,C,D) + E + Wt + Kt;

E = D; D = C; C = S30(B); B = A; A = TEMP;

(5). 令 H0 = H0 + A, H1 = H1 + B, H2 = H2 + C, H3 = H3 + D, H4 = H4 + E.
在处理完所有的 Mn, 后，消息摘要是一个160位的字符串，以下面的顺序标识

H0 H1 H2 H3 H4.

对于SHA256,SHA384,SHA512。你也可以用相似的办法来计算消息摘要。对消息进行补位的算法完全是一样的。

4 参考文献

1: FIPS 180-1 Secure Hash Standard: http://www.itl.nist.gov/fipspubs/fip180-1.htm

2: Secure Hash Standard: http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf

实现代码如下：

using System;
using System.Collections;
using System.IO;
using System.Text;

 namespace VerifySHA1
{
    public class MySHA1
    {
        //   state variables
        private static UInt32 Message_Digest1      = 0x67452301 ;
        private static UInt32 Message_Digest2      = 0xEFCDAB89 ;
        private static UInt32 Message_Digest3      = 0x98BADCFE ;
        private static UInt32 Message_Digest4      = 0x10325476 ;
        private static UInt32 Message_Digest5      = 0xC3D2E1F0 ;

        private static UInt32 SHA1CircularShift( int bits,UInt32 word)
        {
            return ((word << bits) & 0xFFFFFFFF ) | (word) >> ( 32 - (bits));
        }

        private static void SHA1_Init()
        {
            Message_Digest1      = 0x67452301 ;
            Message_Digest2      = 0xEFCDAB89 ;
            Message_Digest3      = 0x98BADCFE ;
            Message_Digest4      = 0x10325476 ;
            Message_Digest5      = 0xC3D2E1F0 ;
        }

        private static UInt32[] SHA1_Append( byte [] input)
        {
            int zeros = 0 ;
            int ones = 1 ;
            int size = 0 ;
            int n = input.Length;
            int m = n % 64 ;
            if ( m < 56 )
            {
                zeros = 55 - m;
                size = n - m + 64 ;
            }
            else if (m == 56 )
            {
                zeros = 63 ;
                ones = 1 ;
                size = n + 8 + 64 ;
            }
            else
            {
                zeros = 63 - m + 56 ;
                size = n + 64 - m + 64 ;
            }

            ArrayList bs = new ArrayList(input);
            if (ones == 1 )
            {
                bs.Add( ( byte ) 0x80 ); // 0x80 = 10000000
            }
            for ( int i = 0 ;i < zeros;i ++ )
            {
                bs.Add( ( byte ) 0 );
            }

            UInt64 N = (UInt64) n * 8 ;
            byte h8 = ( byte )(N & 0xFF );
            byte h7 = ( byte )((N >> 8 ) & 0xFF );
            byte h6 = ( byte )((N >> 16 ) & 0xFF );
            byte h5 = ( byte )((N >> 24 ) & 0xFF );
            byte h4 = ( byte )((N >> 32 ) & 0xFF );
            byte h3 = ( byte )((N >> 40 ) & 0xFF );
            byte h2 = ( byte )((N >> 48 ) & 0xFF );
            byte h1 = ( byte )(N >> 56 );
            bs.Add(h1);
            bs.Add(h2);
            bs.Add(h3);
            bs.Add(h4);
            bs.Add(h5);
            bs.Add(h6);
            bs.Add(h7);
            bs.Add(h8);
            byte [] ts = ( byte [])bs.ToArray( typeof ( byte ));

            /* Decodes input (byte[]) into output (UInt32[]). Assumes len is
             * a multiple of 4.
             */
            UInt32[] output = new UInt32[size / 4 ];
            for (Int64 i = 0 ,j = 0 ;i < size;j ++ ,i += 4 )
            {
                UInt32 temp = 0 ;
                temp = temp | (((UInt32)ts[i]) << 24 );
                temp = temp | (((UInt32)ts[i + 1 ]) << 16 );
                temp = temp | (((UInt32)ts[i + 2 ]) << 8 );
                temp = temp | (((UInt32)ts[i + 3 ]));
                output[j] = temp;
            }
            return output;
        }
        private static UInt32[] SHA1_Transform(UInt32[] x)
        {
            SHA1_Init();

            UInt32[] K = {
                             0x5A827999 ,
                             0x6ED9EBA1 ,
                             0x8F1BBCDC ,
                             0xCA62C1D6
                         };
            int          t;                 
            UInt32    temp;             
            UInt32[]    W = new UInt32[ 80 ];            
            UInt32    A, B, C, D, E;  

            for ( int k = 0 ; k < x.Length; k += 16 )
            {
                for (t = 0 ; t < 16 ; t ++ )
                {
                    W[t] = x[t + k];
                }

                for (t = 16 ; t < 80 ; t ++ )
                {
                    W[t] = SHA1CircularShift( 1 ,W[t - 3 ] ^ W[t - 8 ] ^ W[t - 14 ] ^ W[t - 16 ]);
                }

                A = Message_Digest1;
                B = Message_Digest2;
                C = Message_Digest3;
                D = Message_Digest4;
                E = Message_Digest5;

                for (t = 0 ; t < 20 ; t ++ )
                {
                    temp =   SHA1CircularShift( 5 ,A) +
                        ((B & C) | (( ~ B) & D)) + E + W[t] + K[ 0 ];
                    temp &= 0xFFFFFFFF ;
                    E = D;
                    D = C;
                    C = SHA1CircularShift( 30 ,B);
                    B = A;
                    A = temp;
                }

                for (t = 20 ; t < 40 ; t ++ )
                {
                    temp = SHA1CircularShift( 5 ,A) + (B ^ C ^ D) + E + W[t] + K[ 1 ];
                    temp &= 0xFFFFFFFF ;
                    E = D;
                    D = C;
                    C = SHA1CircularShift( 30 ,B);
                    B = A;
                    A = temp;
                }

                for (t = 40 ; t < 60 ; t ++ )
                {
                    temp = SHA1CircularShift( 5 ,A) +
                        ((B & C) | (B & D) | (C & D)) + E + W[t] + K[ 2 ];
                    temp &= 0xFFFFFFFF ;
                    E = D;
                    D = C;
                    C = SHA1CircularShift( 30 ,B);
                    B = A;
                    A = temp;
                }

                for (t = 60 ; t < 80 ; t ++ )
                {
                    temp = SHA1CircularShift( 5 ,A) + (B ^ C ^ D) + E + W[t] + K[ 3 ];
                    temp &= 0xFFFFFFFF ;
                    E = D;
                    D = C;
                    C = SHA1CircularShift( 30 ,B);
                    B = A;
                    A = temp;
                }

                Message_Digest1 = (Message_Digest1 + A) & 0xFFFFFFFF ;
                Message_Digest2 = (Message_Digest2 + B) & 0xFFFFFFFF ;
                Message_Digest3 = (Message_Digest3 + C) & 0xFFFFFFFF ;
                Message_Digest4 = (Message_Digest4 + D) & 0xFFFFFFFF ;
                Message_Digest5 = (Message_Digest5 + E) & 0xFFFFFFFF ;
            }
       
            return new UInt32[]{Message_Digest1,Message_Digest2,Message_Digest3,Message_Digest4,Message_Digest5};
        }
        public static string SHA1Array(UInt32[] input)
        {
            StringBuilder sb = new StringBuilder();

            for ( int i = 0 ; i < input.Length; i ++ )
            {
                sb.Append( String.Format( " {0:X8} " , input[i]).ToUpper() );
            }

            return sb.ToString();
        }

        public static string MySHA1String( string message)
        {
            char [] c = message.ToCharArray();
            byte [] b = new byte [c.Length];
            for ( int i = 0 ;i < c.Length;i ++ )
            {
                b[i] = ( byte )c[i];
            }
            UInt32[] output = SHA1_Append( b );
            UInt32[] str = SHA1_Transform( output );
            return SHA1Array(str);
           
        }
        public static string MySHA1File( string fileName)
        {
            FileStream fs = File.Open(fileName,FileMode.Open,FileAccess.Read);
            byte [] array = new byte [fs.Length];
            fs.Read(array, 0 ,( int )fs.Length);
            fs.Close();
            UInt32[] output = SHA1_Append( array );
            UInt32[] str = SHA1_Transform( output );
            return SHA1Array(str);
        }
        #region Unit Test
        public static string Test( string message)
        {
            return " \r\nSHA1 (\ "" +message+ " \ " ) = " + MySHA1String(message);
        }
        public static string TestSuite()
        {    
            string s = "" ;
            s += Test( "" );
            s += Test( " a " );
            s += Test( " abc " );
            s += Test( " abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq " );
            s += Test( " abcdefghijklmnopqrstuvwxyz " );
            s += Test( " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 " );
            s += Test( " 12345678901234567890123456789012345678901234567890123456789012345678901234567890 " );
            //         StringBuilder sb = new StringBuilder();
            //         for(int i=0; i<1000000; i++)
            //             sb.Append("a");
            //         s+=Test(sb.ToString());

            return s;    
        }

        public static void Main()
        {
            Console.WriteLine(MySHA1.TestSuite());
            Console.ReadLine();
        }
        #endregion
    }
}

/******************************************************************************************
*【Author】：flyingbread
*【Date】：2007年1月2日
*【Notice】：
*1、本文为原创技术文章，首发博客园个人站点( http://flyingbread.cnblogs.com/)，转载和引用请注明作者及出处。
*2、本文必须全文转载和引用，任何组织和个人未授权不能修改任何内容，并且未授权不可用于商业。
*3、本声明为文章一部分，转载和引用必须包括在原文中。
******************************************************************************************/
dingwood
关注
  • 6
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SHA-1算法的原理与C/C++实现
qq_54223524的博客
01-27 1180
SHA-1 是一种数据加密算法，该算法的思想是接收一段明文，然后以不可逆的方式将其转换为一段密文，这也可以简单理解为输入一串二进制代码并将它们转换为长度更短、位数固定的输出序列，即哈希值，也称为消息摘要或消息认证码。SHA-1算法输入消息的最大长度不超过 2^64 位，得到的输出是一个 160 位的消息摘要。输入以 512 位的数据包进行处理。SHA-1 是不可逆的，具有抗冲突性，并且具有良好的雪崩效应。
现代密码学实验6 散列算法SHA-1的实现
一半西瓜的博客
10-24 3838
赞赏码 & 联系方式 & 个人闲话 【实验名称】散列算法SHA-1的实现 【实验目的】 1、了解散列算法SHA-1的实现过程。 2、实现并掌握SHA-1散列算法。 【实验原理】 安全散列算法是一个密码散列函数家族，是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。且若输入的消息不同，它们对应到不同字符串的机率很高。 ...
前端AES+SHA1PRNG加解密
最新发布
一屁小肥羊的专栏
06-17 352
AES+SHA1PRNG加解密
SHA1算法原理
candy_whut的专栏
02-03 5585
1 SHA1算法简介　　安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程
sha1 算法源码
weixin_30443075的博客
11-08 216
原来指望sha1 这种烂大街的算法 不会出什么幺蛾子 结果《linux C编程实战Code》bt章节的sha1 代码 我在linux和windows下的结果不一样 然后用了哈希工具查看了下 发现结果也不一样。 windows和linux自带工具是一致的，但是和《linux C编程实战Code》的代码 无论在windows还是linux下都不一致 这里记录下新得代码 以后备用 (unbuntu ...
Java实现SHA算法的方法详解
08-27
SHA算法家族包括SHA-1和SHA-2两个主要分支。SHA-1产生160位（20字节）的摘要，而SHA-2则包含一系列不同长度的版本，如SHA-224（224位）、SHA-256（256位）、SHA-384（384位）和SHA-512（512位）。这些算法的安全性...
微信小程序 sha1 实现密码加密实例详解
08-30
微信小程序 sha1 实现密码加密实例详解是指在微信小程序中使用 sha1 算法实现字符串加密的过程。微信小程序 sha1 实现密码加密实例详解主要介绍了微信小程序 sha1 实现密码加密实例详解的相关资料，需要的朋友可以...
Java加密 消息摘要算法SHA实现详解
08-25
主要介绍了Java加密 消息摘要算法SHA实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
详解Java中实现SHA1与MD5加密算法的基本方法
09-02
在Java编程中，SHA1和MD5是两种广泛使用的加密算法，主要用于数据的哈希处理，确保信息的安全性和完整性。本文将详细介绍如何在Java中实现这两种加密算法。 首先，MD5（Message-Digest Algorithm 5）是一种单向哈希...
SHA-1.rar_SHA_SHA-1算法详解_SHA-3_sha-1
07-15
SHA代表安全哈希算法（Secure Hash Algorithm），而1表示这是该系列中的第一个版本。 SHA-1算法的主要作用是对任意长度的数据生成一个固定长度的摘要，通常为160位（20字节）。这个摘要具有碰撞抗性，即相同的输入...
用C语言实现SHA－1算法
04-23
用C语言实现SHA－1算法 用C语言实现SHA－1算法 用C语言实现SHA－1算法用C语言实现SHA－1算法 用C语言实现SHA－1算法
密码学06（SHA1算法）
reforever的博客
11-20 1229
Hash函数 基本形式： hash函数将任意长的报文M映射为定长的hash码h，hash码也称为报文摘要，具有错误检验能力。 基本性质： 单向性：由Hash码不能得出相应的报文。 抗弱碰撞性：不能找到与给定报文具有相同Hash值的另一个报文，保证消息不会伪造。 抗强碰撞性：Hash值应该较长 典型的Hash算法 典型的M-D结构，将明文划分为明文块，再进入到压缩函数处理，输出定长的密文（摘要）...
SHA1算法
纸房子
02-28 3741
SHA1算法
SHA1算法详解
分享各种技术
01-15 6457
SHA1算法详解 SHA1算法作为摘要算法的一种，被使用于各种签名、摘要等场景，本章我们详细分析下SHA1算法细节； 术语定义 word：32bit的String，可以表示为8个16进制的序列，例如A103FE23； integer：表示0-2^32-1之间的数字； block：表示512bit的String，一个block可以表示为16个word的序列（数组）； 消息填充规则 对于待摘要的消息M，先填充一个bit 1，然后填充N个bit 0，最后填充64b.....
java sha 1算法_Java SHA-1算法实现
weixin_42106357的博客
02-12 1274
public class SHA1Util {private static final boolean hexcase = false;private static final String b64pad = "=";private static final int chrsz = 8;// 得到字符串SHA-1值的方法public static String hex_sha1(String s)...
c实现AES 128位加解密
brucewata的专栏
07-02 904
//对应java的SecureRandom随机密钥 bool sha1prng_key(string str,char *out) { unsigned char result[20]; SHA1((unsigned char*)str.c_str(), strlen(str.c_str()), (unsigned char*)&result); SHA1((unsigned char*)&result, 20, (unsigned char*)&result); for (int
SHA1-Hash算法原理
believe_chen的博客
05-30 4268
http://www.burtleburtle.net/bob/hash/doobs.html这个页面提供了对几种流行Hash算法的评价。我们对Hash函数的建议如下： 1.字符串的Hash。最简单可以使用基本的乘法Hash，当乘数为33时，对于英文单词有很好的散列效果（小于6个的小写形式可以保证没有冲突）。复杂一点可以使用FNV算法（及其改进形式），它对于比较长的字符串，在速度和效果...
java SHA1算法实现及详解
07-11
SHA1（Secure Hash Algorithm 1）是一种常用的哈希算法，用于生成消息的摘要。下面是Java中实现SHA1算法的示例代码： ```java import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class SHA1Example { public static void main(String[] args) { String input = "Hello, World!"; String sha1Hash = getSHA1Hash(input); System.out.println("SHA1 Hash: " + sha1Hash); } public static String getSHA1Hash(String input) { try { MessageDigest sha1Digest = MessageDigest.getInstance("SHA-1"); byte[] inputBytes = input.getBytes(); byte[] sha1HashBytes = sha1Digest.digest(inputBytes); StringBuilder hexBuilder = new StringBuilder(); for (byte b : sha1HashBytes) { hexBuilder.append(String.format("%02x", b)); } return hexBuilder.toString(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } return null; } } ``` 上述代码中，我们首先通过`MessageDigest.getInstance("SHA-1")`获取SHA1算法的实例。然后将输入字符串转换为字节数组，并通过`digest`方法计算出SHA1摘要。最后，将摘要转换为十六进制字符串表示。 需要注意的是，SHA1算法已经不再被认为是安全的，因为其哈希长度较短，易受到碰撞攻击。在实际应用中，建议使用更安全的哈希算法，如SHA-256或SHA-512。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值