精华内容
参与话题
问答
  • 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;

        }

     。。。。。 

    展开全文
  • 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那样调整字节位置后再输出,

    展开全文
  • 安全哈希算法(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算法实现及详解

    万次阅读 2017-04-26 13:55:31
    1 SHA1算法简介 安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1...
  • 开发版的sha1值:就是值我们平时开发调试的时候用的sha1值。 1.1运行控制台,输入cmd 1.2 cd .android,定位到.android文件夹下 输入keytool -list -v -keystore debug.keystore, 输入密钥口令:密钥口令是android...
  • sha1加密实现

    千次阅读 2018-11-15 15:08:22
    SHA1加密:安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准 (Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1会产生...
  • 版权声明:本文为博主原创文章,未经博主允许不得转载,否则后果自负。 https://blog.csdn.net/qq_29269233/article/details/53725865 &amp;amp;amp;amp;lt;/div&amp;amp;...stylesh
  • sha1完整源代码

    2013-11-18 21:32:21
    C语言实现 计算并得出指定文件的SHA1值 的功能。
  • SHA1校验算法C语言实现

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

    千次阅读 2018-09-19 16:21:33
    这里重点说一下SHA1算法的实现步骤与代码,由于本人水平有限,不过多讨论SHA1的数学原理以及应用场景。 SHA1简介 In cryptography, SHA-1 (Secure Hash Algorithm 1) is a cryptographic hash function which takes...
  • SHA1实现C语言

    千次阅读 2017-12-17 14:40:52
    因为在我想找sha1加密的时候,没有看到网上可以用的程序,所以就自己找了一下,借用网上大神的例子, 哪个大神具体不记得了。下面是C语言代码: /* * If you do not have the ISO standard stdint.h header file, ...
  • js-sha1实现SHA1加密

    千次阅读 多人点赞 2020-08-18 12:02:22
    实用工具常记录是个好习惯
  • SHA1加签名

    千次阅读 2018-04-26 17:15:34
    一、计算文件public static string HashCode(string str) { string rethash = "... try { System.Security.Cryptography.SHA1 hash = System.Security.Cryptography.SHA1.Create(); Syst...
  • SHA 安全哈希算法(Secure Hash Algorithm)主要适用于...对于长度小于2^64位的消息,SHA1会产生一个160位的消息摘要。该算法经过加密专家多年来的发展和改进已日益完善,并被广泛使用。该算法的思想是接收一段明文...
  • 用M4芯片的HASH模块计算SHA1和HMAC_SHA1

    千次阅读 2015-04-03 20:56:05
    STM32F439芯片,以下用M4称呼。M4的HASH模块,可以计算SHA1、SHA224、SHA256、MD5这些校验值,也可以计算基于它们的HMAC加密校验值,都是硬件计算。在此以SHA1及其HMAC_SHA1为例,讨论其用法。
  • sha1.js(js版sha1加密)

    热门讨论 2013-09-01 16:47:17
    sha1.js(js版sha1加密)
  • LoadRunner/C语言 实现:SHA1加密

    千次阅读 2016-08-11 12:10:12
    //sha1.h:对字符串进行sha1加密 #ifndef _SHA1_H_ #define _SHA1_H_ typedef struct SHA1Context{ unsigned Message_Digest[5]; unsigned Length_Low; unsigned Length_High; unsigned c
  • SHA1和SHA256算法C语言实现

    千次阅读 2018-05-22 17:42:38
    SHA家族的五个算法,分别是SHA-1、SHA-224、SHA-256、SHA-384,和SHA-512,由美国国家安全局(NSA)所设计,并由美国国家标准与技术研究院(NIST)发布...以下先是SHA1的算法 /* * FIPS-180-1 compliant SHA-1 im...

空空如也

1 2 3 4 5 ... 20
收藏数 252,638
精华内容 101,055
关键字:

sha1