sha1_sha1值 - CSDN
精华内容
参与话题
  • SHA1算法原理(转载)

    千次阅读 2018-04-17 14:56:27
    1 SHA1算法简介 安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。 对于长度小于2^64位的消息,SHA1...


    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 = XY逻辑与

    X \/ Y = XY逻辑或

    X XOR Y= XY逻辑异或

    ~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<=32Sn(X) = (X<>32-n)

    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位字BCD并且产生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 计算消息摘要

      必须使用进行了补位和补长度后的消息来计算消息摘要。计算需要两个缓冲区,每个都由532位的字组成,还需要一个8032位字的缓冲区。第一个5个字的缓冲区被标识为ABCDE。第一个5个字的缓冲区被标识为H0, H1, H2, H3, H480个字的缓冲区被标识为W0, W1,..., W79

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

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

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

      在处理每个数据块之前,缓冲区 被初始化为下面的值(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

    5 实现代码如下:

    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            {
                    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】:200712
    *Notice】:
    *1、本文为原创技术文章,首发博客园个人站点(http://flyingbread.cnblogs.com/),转载和引用请注明作者及出处。
    *2、本文必须全文转载和引用,任何组织和个人未授权不能修改任何内容,并且未授权不可用于商业。
    *3、本声明为文章一部分,转载和引用必须包括在原文中。
    ******************************************************************************************/

     


    展开全文
  • SHA1 简单介绍以及使用

    千次阅读 2019-03-19 11:38:56
    SHA-1是一种数据加密算法,该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出...

    原文出处:blog.sina.com.cn/s/blog_a42c4c6c0102woq9.html

    安全哈希算法(Secure Hash Algorithm)

         SHA-1是一种数据加密算法,该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。 

          该算法输入报文的长度不限,产生的输出是一个160位的报文摘要。输入是按512 位的分组进行处理的。SHA-1是不可逆的、防冲突,并具有良好的雪崩效应。

           数字签名的原理是将要传送的明文通过一种函数运算(Hash)转换成报文摘要(不同的明文对应不同的报文摘要),报文摘要加密后与明文一起传送给接受方,接受方将接受的明文产生新的报文摘要与发送方的发来报文摘要解密比较,比较结果一致表示明文未被改动,如果不一致表示明文已被篡改

    简单文字描述:

    客户端:

    在APP 与 后端服务器接口调用的时候,将需要传输的参数进行关键参数(如:String A,String B)进行SHA1加密,获取加密之后的摘要(C);然后在接口调用的时候将参数原文(A,B) 和 加密的摘要(C) 一起传输给后台服务器;

    服务器:

    后台接口接受相关参数,然后将(A,B) 在后台进行SHA1加密,获取加密摘要D,最后将D与C进行比较,如果C == D ,则 A和B 在传输过程中参数没有被窃取改变;如果 C != D,则说明A和B已经在传输过程中发生了改变,最好不要使用!

    注:需要在前后端共同定义一个加密额外秘钥,在进行SHA1加密的过程中添加进去,这样即使在客户端拦截到我们需要传输的参数,进行SHA1 加密,但是由于其不知道 秘钥,所以进行SHA1加密出来的摘要肯定和后端用相关参数、秘钥计算出来的结果不同

    关键SHA1加密代码简单举例:

     public static String createSignature(String... arr) {

            try {

                Arrays.sort(arr);

                StringBuilder content = new StringBuilder();

                for (int i = 0; i < arr.length; i++) {

                    content.append(arr[i]);

                }

                MessageDigest md = MessageDigest.getInstance("SHA-1");

                byte[] digest = md.digest(content.toString().getBytes());

                return byteToStr(digest);

            } catch (Exception e) {

            }

            return null;

        }

     。。。。。 

    展开全文
  • 安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1会产...

    转载:https://blog.csdn.net/jiangyu1013/article/details/73290371

    安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1会产生一个160位的消息摘要。该算法经过加密专家多年来的发展和改进已日益完善,并被广泛使用。该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。散列函数值可以说是对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。

    SHA-1是一种数据加密算法,该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。
    单向散列函数的安全性在于其产生散列值的操作过程具有较强的单向性。如果在输入序列中嵌入密码,那么任何人在不知道密码的情况下都不能产生正确的散列值,从而保证了其安全性。SHA将输入流按照每块512位(64个字节)进行分块,并产生20个字节的被称为信息认证代码或信息摘要的输出。
    该算法输入报文的长度不限,产生的输出是一个160位的报文摘要。输入是按512 位的分组进行处理的。SHA-1是不可逆的、防冲突,并具有良好的雪崩效应。
    通过散列算法可实现数字签名实现,数字签名的原理是将要传送的明文通过一种函数运算(Hash)转换成报文摘要(不同的明文对应不同的报文摘要),报文摘要加密后与明文一起传送给接受方,接受方将接受的明文产生新的报文摘要与发送方的发来报文摘要解密比较,比较结果一致表示明文未被改动,如果不一致表示明文已被篡改。
    MAC (信息认证代码)就是一个散列结果,其中部分输入信息是密码,只有知道这个密码的参与者才能再次计算和验证MAC码的合法性。

    SHA-1与MD5的比较
    因为二者均由MD4导出,SHA-1和MD5彼此很相似。相应的,他们的强度和其他特性也是相似,但还有以下几点不同:
    l 对强行攻击的安全性:最显著和最重要的区别是SHA-1摘要比MD5摘要长32 位。使用强行技术,产生任何一个报文使其摘要等于给定报摘要的难度对MD5是2128数量级的操作,而对SHA-1则是2160数量级的操作。这样,SHA-1对强行攻击有更大的强度。
    l 对密码分析的安全性:由于MD5的设计,易受密码分析的攻击,SHA-1显得不易受这样的攻击。
    l 速度:在相同的硬件上,SHA-1的运行速度比MD5慢。

    展开全文
  • SHA1算法详解

    万次阅读 2018-08-25 13:30:00
    SHA1算法也是哈希算法的一种,只要理解了MD5算法,SHA1也很快就能理解。 MD5算法可以参考:MD5算法详解 MD5算法得出的MD5值长度为16个字节(8*16=128位) SHA1算法得出的SHA1值长度为20个字节(8*20=160位) 0x...

    0x00 前言

    SHA1算法也是哈希算法的一种,只要理解了MD5算法,SHA1也很快就能理解。
    MD5算法可以参考:MD5算法详解
    MD5算法得出的MD5值长度为16个字节(8*16=128位)
    SHA1算法得出的SHA1值长度为20个字节(8*20=160位)

    0x01 填充信息

    和MD5算法类似,对信息的第一步也是填充信息直至满足条件。

    填充的过程如下:
    1.先判断文件(消息)的大小(长度) mod 512 == 448 mod 512 ,就是大小(长度)对512求余等于448。(这里的512、448是“位”为单位,转成“字节”就是64、56,即mod 64 == 56 mod 64)

    2.如果大小(长度)满足 mod 512 == 448 mod 512,就在文件(消息)的末尾处添加64位(8字节)的值,值的内容是原消息的长度(以位为单位)

    3.如果大小(长度)不满足要求,就执行以下操作:
    (1)填充1个1
    (2)填充0,直到满足满足过程的第一步。

    注意:这里是以位为单位,假如是以字节为单位,第一个填充的是0x80(1000 0000),然后就填0x0
    举例:消息内容为“gnubd”,就能得到以下内容

    67 6E 62 75 64 80 00 00 00 00 00 00 00 00 00 00
    00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
    00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
    00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 28 

    还需要注意到的是最后原消息的长度是以大端存储的方式存到内存中的,这里与MD5的存储是有区别的。

    0x02 数据说明

    这里列举出所用到的数据

    DWORD sha1::A = 0x67452301;
    DWORD sha1::B = 0xEFCDAB89;
    DWORD sha1::C = 0x98BADCFE;
    DWORD sha1::D = 0x10325476;
    DWORD sha1::E = 0xC3D2E1F0;

    这里相对MD5算法多了4个字节。(因为SHA1值就是比MD5值多4个字节嘛)

    常量:

    DWORD sha1::k[4] = {0x5A827999,0x6ED9EBA1,0x8F1BBCDC,0xCA62C1D6};

    MD5就有64个,这个就简单一点,4个

    0x03 处理信息

    和MD5算法类似,也是需要将消息分组,每64个字节(512位)一组,分成多个组(n个)。
    对与每一组Mi(0 < i <= n)都要做如下处理。
    将64个字节分成16组w0-w15,每组刚好4个字节
    然后生成w16-w79,生成的方法如下:

    for(DWORD i = 16;i<80;i++){
            DWORD temp = w[i-3]^w[i-8]^w[i-14]^w[i-16];
            w[i] = temp<<1 | temp>>31;
        }

    接下来就是做核心运算了。
    将a、b、c、d、e分别赋值为上面的A、B、C、D、E,作为Mi的初始值
    然后循环80次,从0-79:

            for(DWORD j = 0;j<80;j++){
                    DWORD temp;
                    DWORD temp2 = a<<5|a>>27; //循环左移5位,等下需要用到
                    switch(j/20){   
                    case 0:   //0-19步执行这里
                        temp = (b&c)|((~(b))&d);
                        temp += sha1::k[0];  //这个是常数
                        break;
                    case 1:  //20-39步执行这里
                        temp = (b^c^d);
                        temp += sha1::k[1];
                        break;
                    case 2: //40-59步执行这里
                        temp = (b&c)|(b&d)|(c&d);
                        temp += sha1::k[2];
                        break;
                    case 3: //60-79步执行这里
                        temp = (b^c^d);
                        temp += sha1::k[3];
                        break;
                    }
                    temp += temp2 + e + w[j]; //这里就是上面生成的80个分组了
                    e = d;
                    d = c;
                    c = b<<30 | b>>2; //循环左移30位
                    b = a;
                    a = temp;
                }
            A+=a;
            B+=b;
            C+=c;
            D+=d;
            E+=e;

    注意最后这里和MD5类似,也是再将abcde分别加上初始值ABCDE,作为下一个消息分组Mi+1的初始值,直到最后一个分组Mn计算完后,得出的结果就是SHA1值。
    即:
    MnAMnBMnCMnDMnE
    这里只需按直接输出就好了,不必像md5那样调整字节位置后再输出,

    展开全文
  • sha1的实现

    2020-07-30 23:32:25
    实现sha1算法代码,并且有详细备注,便于学习者开发学习使用
  • 终于有了一个实例:SHA1冲突实例

    千次阅读 2017-02-24 12:14:30
    都知道任何哈希算法都有可能产生冲突,也就是说不同内容产生相同的哈希码,MD5早就有过两个不同的图片的实例,但是SHA1的在现实中很难遇到,有好多好多的应用还是依赖于它作为标识,要找到一个实例还是相当的困难。...
  • SHA1原理及处理步骤,附示例

    万次阅读 2018-09-05 09:55:14
    SHA1原理及处理步骤,附示例 SHA1原理及处理步骤,附示例 声明常量及运算符: 预处理 转成位 补位 填入原数据长度 示例 运算 求Mn 求Wn 求H0~H4 按顺序拼接H0 H1 H2 H3 H4,即可得到结果 示例 输入...
  • SHA1

    2019-05-15 10:56:59
    https://blog.csdn.net/u010144805/article/details/80803380 #ifndef G_SHA1_H #define G_SHA1_H #include "publish.h" /** * \brief SHA-1 context structure */ typedef struct { uint32_t ...
  • SHA1算法实现及详解

    万次阅读 2017-04-26 13:57:36
    1 SHA1算法简介 安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1...
  • SHA1校验算法C语言实现

    万次阅读 2016-07-31 21:26:14
    SHA1 安全哈希算法:对于长度小于2^64位的消息(1M = 1024k,1K = 1024字节,1BYTE = 8bit 可以想象一下2的63次方位可以表示一个多大的数据文件),SHA1会产生一个160位的消息摘要。当接收到消息的时候,这个消息摘要...
  • sha1 -- 生成 sha1 散列值 》中给出了可以生成 SHA1() 函数,它应用很简单。实际上,OpenSSL 还提供了另外一套 API 用以产生 sha1 散列值,该套 API 可以生成更大文件的散列值。比如在 32 位系统下,...
  • Windows自带MD5 SHA1 SHA256命令行工具

    万次阅读 2018-03-07 01:29:18
    certutil -hashfile &lt;文件名&gt; &lt;hash类型&gt;如:
  • Windows系统中通过命令查看文件的MD5,SHA1,SHA256校验值命令格式如下:certutil -hashfile yourfilename MD5certutil -hashfile yourfilename SHA1certutil -hashfile yourfilename SHA256示例:...
  • HMAC_SHA1SHA1的区别

    万次阅读 2012-12-18 13:37:30
    一直以为HMAC_SHA1SHA1没有任何区别,直到现在才发现它俩不是完全一样的。 HMAC的百度百科解释: “HMAC是密钥相关的哈希运算消息认证码(Hash-based Message Authentication Code),HMAC运算利用哈希算法,以...
  • certutil -hashfile yourfilename.ext MD5certutil -hashfile yourfilename.ext SHA1certutil -hashfile yourfilename.ext SHA256
  • C# sha256 加密算法

    万次阅读 2018-04-20 15:36:52
    C# 非对称加密public string sha256(string data) { byte[] bytes = Encoding.UTF8.GetBytes(data); byte[] hash = SHA256Managed.Create().ComputeHash(bytes); StringBuilder builder = new StringBuilder();....
  • 生成文件的MD5、SHASHA256

    万次阅读 2017-01-23 18:16:04
    生成文件的MD5、SHA、SHA256 Linux系统生成MD5、SHA、SHA256 md5sum file1.zip >> MD5.txt ...sha1sum file1.zip >> SHA1.txt sha256sum file1.zip >> SHA256.txt windows系统生成MD5、SHA、SHA256 certu
  • 如何查看文件的md5校验码、sha1校验码和sha256校验码 本文是基于Windows 10系统和ubuntu 14.04系统环境,使用命令查看文件的md5校验码、sha1校验码和sha256校验码: Windows 10 Ubuntu 14.04 Windows命令 进入...
  • 在linux下生成sha256校验文件的方法例如要对“a”这个文件生成一个sha256的校验文件; 方法如下:sha256sum a > a.sha256sum 也就是:sha256sum 文件名 > 文件名.sha256.sum 然后a.sha256sum这个校验文件就会在a同...
  • python sha1加密字符串

    万次阅读 2018-12-20 10:26:59
    直接调用该方法即可实现sha1加密 def get_str_sha1_secret_str(res:str): import hashlib """ 使用sha1加密算法,返回str加密后的字符串 """ sha = hashlib.sha1(res.encode('...
1 2 3 4 5 ... 20
收藏数 228,167
精华内容 91,266
关键字:

sha1